Merge branch 'main' into confluence-importer

apps/server/src/database/migrations/20260529T125146-bases.ts

@@ -0,0 +1,249 @@
+import { type Kysely, sql } from 'kysely';
+
+export async function up(db: Kysely<any>): Promise<void> {
+  await db.schema
+    .alterTable('pages')
+    .addColumn('is_base', 'boolean', (col) =>
+      col.ifNotExists().notNull().defaultTo(false),
+    )
+    .addColumn('base_schema_version', 'integer', (col) =>
+      col.ifNotExists().notNull().defaultTo(0),
+    )
+    .execute();
+
+  await sql`
+    CREATE INDEX IF NOT EXISTS idx_pages_is_base
+      ON pages (space_id, position COLLATE "C")
+      WHERE is_base = true AND deleted_at IS NULL
+  `.execute(db);
+
+  await db.schema
+    .createTable('base_properties')
+    .ifNotExists()
+    .addColumn('id', 'varchar', (col) => col.notNull())
+    .addColumn('page_id', 'uuid', (col) =>
+      col.references('pages.id').onDelete('cascade').notNull(),
+    )
+    .addColumn('name', 'varchar', (col) => col.notNull())
+    .addColumn('type', 'varchar', (col) => col.notNull())
+    .addColumn('position', 'varchar', (col) => col.notNull())
+    .addColumn('type_options', 'jsonb')
+    .addColumn('pending_type', 'varchar')
+    .addColumn('pending_type_options', 'jsonb')
+    .addColumn('pending_token', 'uuid')
+    .addColumn('is_primary', 'boolean', (col) => col.notNull().defaultTo(false))
+    .addColumn('schema_version', 'integer', (col) => col.notNull().defaultTo(1))
+    .addColumn('workspace_id', 'uuid', (col) =>
+      col.references('workspaces.id').onDelete('cascade').notNull(),
+    )
+    .addColumn('created_at', 'timestamptz', (col) =>
+      col.notNull().defaultTo(sql`now()`),
+    )
+    .addColumn('updated_at', 'timestamptz', (col) =>
+      col.notNull().defaultTo(sql`now()`),
+    )
+    .addColumn('deleted_at', 'timestamptz')
+    .addPrimaryKeyConstraint('base_properties_pkey', ['page_id', 'id'])
+    .execute();
+
+  await sql`CREATE INDEX IF NOT EXISTS idx_base_properties_page_id ON base_properties (page_id)`.execute(
+    db,
+  );
+
+  await sql`
+    CREATE INDEX IF NOT EXISTS idx_base_properties_page_alive
+      ON base_properties (page_id, position COLLATE "C", id)
+      WHERE deleted_at IS NULL
+  `.execute(db);
+
+  // Match the service-layer name check (name.trim().toLowerCase()) so
+  // whitespace-padded duplicates also collide. Formulas look properties up by
+  // name, so the names have to stay unique.
+  await sql`
+    CREATE UNIQUE INDEX IF NOT EXISTS base_properties_page_name_alive_unique
+      ON base_properties (page_id, lower(trim(name)))
+      WHERE deleted_at IS NULL
+  `.execute(db);
+
+  await db.schema
+    .createTable('base_rows')
+    .ifNotExists()
+    .addColumn('id', 'uuid', (col) =>
+      col.primaryKey().defaultTo(sql`gen_uuid_v7()`),
+    )
+    .addColumn('page_id', 'uuid', (col) =>
+      col.references('pages.id').onDelete('cascade').notNull(),
+    )
+    .addColumn('cells', 'jsonb', (col) =>
+      col.notNull().defaultTo(sql`'{}'::jsonb`),
+    )
+    .addColumn('position', 'varchar', (col) => col.notNull())
+    .addColumn('creator_id', 'uuid', (col) =>
+      col.references('users.id').onDelete('set null'),
+    )
+    .addColumn('last_updated_by_id', 'uuid', (col) =>
+      col.references('users.id').onDelete('set null'),
+    )
+    .addColumn('workspace_id', 'uuid', (col) =>
+      col.references('workspaces.id').onDelete('cascade').notNull(),
+    )
+    .addColumn('created_at', 'timestamptz', (col) =>
+      col.notNull().defaultTo(sql`now()`),
+    )
+    .addColumn('updated_at', 'timestamptz', (col) =>
+      col.notNull().defaultTo(sql`now()`),
+    )
+    .addColumn('deleted_at', 'timestamptz')
+    .execute();
+
+  await sql`
+    CREATE INDEX IF NOT EXISTS idx_base_rows_page_alive
+      ON base_rows (page_id, position COLLATE "C", id)
+      WHERE deleted_at IS NULL
+  `.execute(db);
+
+  await sql`
+    CREATE INDEX IF NOT EXISTS idx_base_rows_page_updated
+      ON base_rows (page_id, updated_at DESC)
+      WHERE deleted_at IS NULL
+  `.execute(db);
+
+  await sql`
+    CREATE INDEX IF NOT EXISTS idx_base_rows_page_created
+      ON base_rows (page_id, created_at DESC)
+      WHERE deleted_at IS NULL
+  `.execute(db);
+
+  await db.schema
+    .createTable('base_views')
+    .ifNotExists()
+    .addColumn('id', 'uuid', (col) =>
+      col.primaryKey().defaultTo(sql`gen_uuid_v7()`),
+    )
+    .addColumn('page_id', 'uuid', (col) =>
+      col.references('pages.id').onDelete('cascade').notNull(),
+    )
+    .addColumn('name', 'varchar', (col) => col.notNull())
+    .addColumn('type', 'varchar', (col) => col.notNull().defaultTo('table'))
+    .addColumn('position', 'varchar', (col) => col.notNull())
+    .addColumn('config', 'jsonb', (col) =>
+      col.notNull().defaultTo(sql`'{}'::jsonb`),
+    )
+    .addColumn('workspace_id', 'uuid', (col) =>
+      col.references('workspaces.id').onDelete('cascade').notNull(),
+    )
+    .addColumn('creator_id', 'uuid', (col) =>
+      col.references('users.id').onDelete('set null'),
+    )
+    .addColumn('created_at', 'timestamptz', (col) =>
+      col.notNull().defaultTo(sql`now()`),
+    )
+    .addColumn('updated_at', 'timestamptz', (col) =>
+      col.notNull().defaultTo(sql`now()`),
+    )
+    .execute();
+
+  await sql`CREATE INDEX IF NOT EXISTS idx_base_views_page_id ON base_views (page_id)`.execute(
+    db,
+  );
+
+  // Cell extraction helpers for filters and sorts. Return NULL for absent or
+  // non-castable values.
+  await sql`
+    CREATE OR REPLACE FUNCTION base_cell_text(cells jsonb, prop text)
+    RETURNS text LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
+    AS $$ SELECT cells->>prop::text $$
+  `.execute(db);
+
+  await sql`
+    CREATE OR REPLACE FUNCTION base_cell_numeric(cells jsonb, prop text)
+    RETURNS numeric LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
+    AS $$
+      SELECT CASE jsonb_typeof(cells->prop::text)
+        WHEN 'number' THEN (cells->>prop::text)::numeric
+        WHEN 'string' THEN
+          CASE
+            WHEN (cells->>prop::text) ~
+              '^[[:space:]]*[+-]?([0-9]+([.][0-9]*)?|[.][0-9]+)([eE][+-]?[0-9]+)?[[:space:]]*$'
+            THEN (cells->>prop::text)::numeric
+          END
+      END
+    $$
+  `.execute(db);
+
+  // A DATE cell stores an arbitrary string (cell schema is z.string()), so the
+  // cast can fail on values no regex can pre-validate (e.g. '2024-13-45'). This
+  // helper uses plpgsql with an EXCEPTION handler to return NULL on failure.
+  await sql`
+    CREATE OR REPLACE FUNCTION base_cell_timestamptz(cells jsonb, prop text)
+    RETURNS timestamptz LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE
+    AS $$
+      BEGIN RETURN (cells->>prop::text)::timestamptz;
+      EXCEPTION WHEN others THEN RETURN NULL; END;
+    $$
+  `.execute(db);
+
+  await sql`
+    CREATE OR REPLACE FUNCTION base_cell_bool(cells jsonb, prop text)
+    RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
+    AS $$
+      SELECT CASE jsonb_typeof(cells->prop::text)
+        WHEN 'boolean' THEN (cells->>prop::text)::boolean
+        WHEN 'string' THEN
+          CASE
+            WHEN lower(btrim(cells->>prop::text)) IN
+              ('true','t','yes','y','on','1','false','f','no','n','off','0')
+            THEN (cells->>prop::text)::boolean
+          END
+      END
+    $$
+  `.execute(db);
+
+  await sql`
+    CREATE OR REPLACE FUNCTION base_cell_array(cells jsonb, prop text)
+    RETURNS jsonb LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
+    AS $$ SELECT cells->prop::text $$
+  `.execute(db);
+
+  // A null patch value deletes the key rather than storing a JSON null.
+  await sql`
+    CREATE OR REPLACE FUNCTION jsonb_set_many(target jsonb, patches jsonb)
+    RETURNS jsonb LANGUAGE plpgsql IMMUTABLE PARALLEL SAFE
+    AS $$
+      DECLARE k text; v jsonb; result jsonb := coalesce(target, '{}'::jsonb);
+      BEGIN
+        IF patches IS NULL OR jsonb_typeof(patches) <> 'object' THEN
+          RETURN result;
+        END IF;
+        FOR k, v IN SELECT * FROM jsonb_each(patches) LOOP
+          IF v = 'null'::jsonb THEN
+            result := result - k;
+          ELSE
+            result := jsonb_set(result, ARRAY[k], v, true);
+          END IF;
+        END LOOP;
+        RETURN result;
+      END;
+    $$
+  `.execute(db);
+}
+
+export async function down(db: Kysely<any>): Promise<void> {
+  await db.schema.dropTable('base_views').execute();
+  await db.schema.dropTable('base_rows').execute();
+  await db.schema.dropTable('base_properties').execute();
+
+  await sql`DROP FUNCTION jsonb_set_many(jsonb, jsonb)`.execute(db);
+  await sql`DROP FUNCTION base_cell_array(jsonb, text)`.execute(db);
+  await sql`DROP FUNCTION base_cell_bool(jsonb, text)`.execute(db);
+  await sql`DROP FUNCTION base_cell_timestamptz(jsonb, text)`.execute(db);
+  await sql`DROP FUNCTION base_cell_numeric(jsonb, text)`.execute(db);
+  await sql`DROP FUNCTION base_cell_text(jsonb, text)`.execute(db);
+
+  await sql`DROP INDEX idx_pages_is_base`.execute(db);
+  await db.schema
+    .alterTable('pages')
+    .dropColumn('base_schema_version')
+    .dropColumn('is_base')
+    .execute();
+}

apps/server/src/database/migrations/20260620T010047-personal-spaces.ts

@@ -0,0 +1,24 @@
+import { Kysely, sql } from 'kysely';
+
+export async function up(db: Kysely<any>): Promise<void> {
+  await db.schema
+    .alterTable('spaces')
+    .addColumn('is_personal', 'boolean', (col) =>
+      col.notNull().defaultTo(false),
+    )
+    .execute();
+
+  await sql`
+    CREATE UNIQUE INDEX spaces_personal_creator_unique
+    ON spaces (creator_id)
+    WHERE is_personal = true AND deleted_at IS NULL
+  `.execute(db);
+}
+
+export async function down(db: Kysely<any>): Promise<void> {
+  await db.schema
+    .dropIndex('spaces_personal_creator_unique')
+    .ifExists()
+    .execute();
+  await db.schema.alterTable('spaces').dropColumn('is_personal').execute();
+}

apps/server/src/database/pagination/cursor-pagination.ts

@@ -14,12 +14,14 @@ type SortField<DB, TB extends keyof DB, O> =
         | (StringReference<DB, TB> & `${string}.${keyof O & string}`);
       direction: OrderByDirection;
       orderModifier?: OrderByModifiers;
+      cursorExpression?: ReferenceExpression<DB, TB>;
       key?: keyof O & string;
     }
   | {
       expression: ReferenceExpression<DB, TB>;
       direction: OrderByDirection;
       orderModifier?: OrderByModifiers;
+      cursorExpression?: ReferenceExpression<DB, TB>;
       key: keyof O & string;
     };
 
@@ -202,11 +204,12 @@ export async function executeWithCursorPagination<
 
         const comparison = field.direction === defaultDirection ? '>' : '<';
         const value = cursor[field.key as keyof typeof cursor];
+        const compareExpr = field.cursorExpression ?? field.expression;
 
-        const conditions = [eb(field.expression, comparison, value)];
+        const conditions = [eb(compareExpr, comparison, value)];
 
         if (expression) {
-          conditions.push(and([eb(field.expression, '=', value), expression]));
+          conditions.push(and([eb(compareExpr, '=', value), expression]));
         }
 
         expression = or(conditions);

apps/server/src/database/repos/favorite/favorite.repo.ts

@@ -236,6 +236,7 @@ export class FavoriteRepo {
           'pages.slugId',
           'pages.title',
           'pages.icon',
+          'pages.isBase',
           'pages.spaceId',
         ])
         .whereRef('pages.id', '=', 'favorites.pageId'),

apps/server/src/database/repos/page/page.repo.ts

@@ -38,6 +38,7 @@ export class PageRepo {
     'spaceId',
     'workspaceId',
     'isLocked',
+    'isBase',
     'createdAt',
     'updatedAt',
     'deletedAt',

apps/server/src/database/repos/space/space.repo.ts

@@ -57,6 +57,22 @@ export class SpaceRepo {
       .executeTakeFirst();
   }
 
+  async findPersonalSpace(
+    userId: string,
+    workspaceId: string,
+    trx?: KyselyTransaction,
+  ): Promise<Space | undefined> {
+    const db = dbOrTx(this.db, trx);
+    return db
+      .selectFrom('spaces')
+      .selectAll('spaces')
+      .where('workspaceId', '=', workspaceId)
+      .where('creatorId', '=', userId)
+      .where('isPersonal', '=', true)
+      .where('deletedAt', 'is', null)
+      .executeTakeFirst();
+  }
+
   async slugExists(
     slug: string,
     workspaceId: string,

apps/server/src/database/repos/template/template.repo.ts

@@ -63,11 +63,9 @@ export class TemplateRepo {
 
     if (opts?.spaceId) {
       if (!accessibleSpaceIds.includes(opts.spaceId)) {
-        query = query.where('spaceId', 'is', null);
+        query = query.where(sql<boolean>`false`);
       } else {
-        query = query.where((eb) =>
-          eb.or([eb('spaceId', '=', opts.spaceId), eb('spaceId', 'is', null)]),
-        );
+        query = query.where('spaceId', '=', opts.spaceId);
       }
     } else {
       query = query.where((eb) =>

apps/server/src/database/repos/workspace/workspace.repo.ts

@@ -251,4 +251,24 @@ export class WorkspaceRepo {
       .executeTakeFirst();
   }
 
+  async updateSpaceSettings(
+    workspaceId: string,
+    prefKey: string,
+    prefValue: string | boolean,
+    trx?: KyselyTransaction,
+  ) {
+    const db = dbOrTx(this.db, trx);
+    return db
+      .updateTable('workspaces')
+      .set({
+        settings: sql`COALESCE(settings, '{}'::jsonb)
+                || jsonb_build_object('spaces', COALESCE(settings->'spaces', '{}'::jsonb)
+                || jsonb_build_object('${sql.raw(prefKey)}', ${sql.lit(prefValue)}))`,
+        updatedAt: new Date(),
+      })
+      .where('id', '=', workspaceId)
+      .returning(this.baseFields)
+      .executeTakeFirst();
+  }
+
 }

apps/server/src/database/types/db.d.ts

@@ -126,6 +126,50 @@ export interface Backlinks {
   workspaceId: string;
 }
 
+export interface BaseProperties {
+  createdAt: Generated<Timestamp>;
+  deletedAt: Timestamp | null;
+  id: Generated<string>;
+  isPrimary: Generated<boolean>;
+  name: string;
+  pageId: string;
+  pendingType: string | null;
+  pendingTypeOptions: Json | null;
+  pendingToken: string | null;
+  position: string;
+  schemaVersion: Generated<number>;
+  type: string;
+  typeOptions: Json | null;
+  updatedAt: Generated<Timestamp>;
+  workspaceId: string;
+}
+
+export interface BaseRows {
+  cells: Generated<Json>;
+  createdAt: Generated<Timestamp>;
+  creatorId: string | null;
+  deletedAt: Timestamp | null;
+  id: Generated<string>;
+  lastUpdatedById: string | null;
+  pageId: string;
+  position: string;
+  updatedAt: Generated<Timestamp>;
+  workspaceId: string;
+}
+
+export interface BaseViews {
+  config: Generated<Json>;
+  createdAt: Generated<Timestamp>;
+  creatorId: string | null;
+  id: Generated<string>;
+  name: string;
+  pageId: string;
+  position: string;
+  type: Generated<string>;
+  updatedAt: Generated<Timestamp>;
+  workspaceId: string;
+}
+
 export interface Billing {
   amount: Int8 | null;
   billingScheme: string | null;
@@ -275,6 +319,8 @@ export interface Pages {
   deletedById: string | null;
   icon: string | null;
   id: Generated<string>;
+  isBase: Generated<boolean>;
+  baseSchemaVersion: Generated<number>;
   isLocked: Generated<boolean>;
   lastUpdatedById: string | null;
   parentPageId: string | null;
@@ -322,6 +368,7 @@ export interface Spaces {
   deletedAt: Timestamp | null;
   description: string | null;
   id: Generated<string>;
+  isPersonal: Generated<boolean>;
   logo: string | null;
   name: string | null;
   settings: Json | null;
@@ -598,6 +645,9 @@ export interface DB {
   authAccounts: AuthAccounts;
   authProviders: AuthProviders;
   backlinks: Backlinks;
+  baseProperties: BaseProperties;
+  baseRows: BaseRows;
+  baseViews: BaseViews;
   billing: Billing;
   comments: Comments;
   favorites: Favorites;

apps/server/src/database/types/entity.types.ts

@@ -3,6 +3,9 @@ import {
   AiChats,
   AiChatMessages,
   Attachments,
+  BaseProperties,
+  BaseRows,
+  BaseViews,
   Comments,
   Groups,
   Labels,
@@ -238,3 +241,18 @@ export type UpdatableAudit = Updateable<Omit<_Audit, 'id'>>;
 export type Template = Selectable<Templates>;
 export type InsertableTemplate = Insertable<Templates>;
 export type UpdatableTemplate = Updateable<Omit<Templates, 'id'>>;
+
+// Base Property
+export type BaseProperty = Selectable<BaseProperties>;
+export type InsertableBaseProperty = Insertable<BaseProperties>;
+export type UpdatableBaseProperty = Updateable<Omit<BaseProperties, 'id'>>;
+
+// Base Row
+export type BaseRow = Selectable<BaseRows>;
+export type InsertableBaseRow = Insertable<BaseRows>;
+export type UpdatableBaseRow = Updateable<Omit<BaseRows, 'id'>>;
+
+// Base View
+export type BaseView = Selectable<BaseViews>;
+export type InsertableBaseView = Insertable<BaseViews>;
+export type UpdatableBaseView = Updateable<Omit<BaseViews, 'id'>>;