@orthacms/content-server 0.4.2 → 0.5.0

package/dist/lib/views/infrastructure/persistence/drizzle-saved-view.repository.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DrizzleSavedViewRepository = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const database_1 = require("@orthacms/database");
+const drizzle_orm_1 = require("drizzle-orm");
+const saved_views_1 = require("../schema/saved-views");
+const saved_view_1 = require("../../domain/saved-view");
+const errors_1 = require("../../domain/errors");
+/** The columns every read of this table projects. */
+const COLUMNS = {
+    id: saved_views_1.savedViews.id,
+    workspaceId: saved_views_1.savedViews.workspaceId,
+    scope: saved_views_1.savedViews.scope,
+    ownerId: saved_views_1.savedViews.ownerId,
+    visibility: saved_views_1.savedViews.visibility,
+    name: saved_views_1.savedViews.name,
+    payload: saved_views_1.savedViews.payload,
+    position: saved_views_1.savedViews.position,
+    updatedAt: saved_views_1.savedViews.updatedAt
+};
+/** Narrows the enum column's `string` back to the domain union. */
+function toRecord(row) {
+    return { ...row, visibility: row.visibility };
+}
+/** Drizzle adapter for {@link SavedViewRepository}. */
+let DrizzleSavedViewRepository = class DrizzleSavedViewRepository {
+    uow;
+    constructor(uow) {
+        this.uow = uow;
+    }
+    /**
+     * The executor to run against: the ambient transaction when a caller opened
+     * one, the base connection otherwise.
+     *
+     * It exists so a view write and the `saved_view.*` event describing it
+     * commit together. Outside a unit of work this is the old behaviour
+     * exactly — `UnitOfWork.current()` falls back to the pool.
+     */
+    get db() {
+        return this.uow.current();
+    }
+    async listVisible(workspaceId, scope, readerId) {
+        const rows = await this.db
+            .select(COLUMNS)
+            .from(saved_views_1.savedViews)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(saved_views_1.savedViews.workspaceId, workspaceId), (0, drizzle_orm_1.eq)(saved_views_1.savedViews.scope, scope), 
+        // Own views at any visibility, plus everyone's shared ones.
+        (0, drizzle_orm_1.or)((0, drizzle_orm_1.eq)(saved_views_1.savedViews.ownerId, readerId), (0, drizzle_orm_1.eq)(saved_views_1.savedViews.visibility, saved_view_1.VIEW_VISIBILITY.Workspace))))
+            .orderBy((0, drizzle_orm_1.asc)(saved_views_1.savedViews.position), (0, drizzle_orm_1.asc)(saved_views_1.savedViews.createdAt), (0, drizzle_orm_1.asc)(saved_views_1.savedViews.id));
+        return rows.map(toRecord);
+    }
+    async findById(id) {
+        const [row] = await this.db
+            .select(COLUMNS)
+            .from(saved_views_1.savedViews)
+            .where((0, drizzle_orm_1.eq)(saved_views_1.savedViews.id, id))
+            .limit(1);
+        return row ? toRecord(row) : null;
+    }
+    async countForOwner(workspaceId, scope, ownerId) {
+        const [row] = await this.db
+            .select({ count: (0, drizzle_orm_1.sql) `count(*)::int` })
+            .from(saved_views_1.savedViews)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(saved_views_1.savedViews.workspaceId, workspaceId), (0, drizzle_orm_1.eq)(saved_views_1.savedViews.scope, scope), (0, drizzle_orm_1.eq)(saved_views_1.savedViews.ownerId, ownerId)));
+        return row?.count ?? 0;
+    }
+    async create(view) {
+        const [row] = await this.db
+            .insert(saved_views_1.savedViews)
+            .values({
+            workspaceId: view.workspaceId,
+            scope: view.scope,
+            ownerId: view.ownerId,
+            visibility: view.visibility,
+            name: view.name,
+            payload: view.payload
+        })
+            .returning(COLUMNS);
+        return toRecord(row);
+    }
+    async update(id, patch) {
+        const [row] = await this.db
+            .update(saved_views_1.savedViews)
+            .set({
+            ...(patch.name !== undefined ? { name: patch.name } : {}),
+            ...(patch.visibility !== undefined
+                ? { visibility: patch.visibility }
+                : {}),
+            ...(patch.payload !== undefined
+                ? { payload: patch.payload }
+                : {})
+        })
+            .where((0, drizzle_orm_1.eq)(saved_views_1.savedViews.id, id))
+            .returning(COLUMNS);
+        // The use-case reads the row before patching, so a miss here means it
+        // was deleted in between — surface the same not-found the read would.
+        if (!row)
+            throw new errors_1.SavedViewNotFoundError(id);
+        return toRecord(row);
+    }
+    async delete(id) {
+        await this.db.delete(saved_views_1.savedViews).where((0, drizzle_orm_1.eq)(saved_views_1.savedViews.id, id));
+    }
+    async findDefaultId(userId, scope) {
+        const [row] = await this.db
+            .select({ viewId: saved_views_1.savedViewDefaults.viewId })
+            .from(saved_views_1.savedViewDefaults)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(saved_views_1.savedViewDefaults.userId, userId), (0, drizzle_orm_1.eq)(saved_views_1.savedViewDefaults.scope, scope)))
+            .limit(1);
+        return row?.viewId ?? null;
+    }
+    async setDefault(userId, scope, viewId) {
+        await this.db
+            .insert(saved_views_1.savedViewDefaults)
+            .values({ userId, scope, viewId })
+            // One row per (user, scope) — re-pointing the default is an upsert,
+            // not a delete-then-insert that could lose the row on a crash.
+            .onConflictDoUpdate({
+            target: [saved_views_1.savedViewDefaults.userId, saved_views_1.savedViewDefaults.scope],
+            set: { viewId }
+        });
+    }
+    async clearDefault(userId, scope) {
+        await this.db
+            .delete(saved_views_1.savedViewDefaults)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(saved_views_1.savedViewDefaults.userId, userId), (0, drizzle_orm_1.eq)(saved_views_1.savedViewDefaults.scope, scope)));
+    }
+};
+exports.DrizzleSavedViewRepository = DrizzleSavedViewRepository;
+exports.DrizzleSavedViewRepository = DrizzleSavedViewRepository = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__metadata("design:paramtypes", [database_1.UnitOfWork])
+], DrizzleSavedViewRepository);

package/dist/lib/views/infrastructure/schema/external-refs.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Reference-only projections of the tables this feature's foreign keys target.
+ * Identity owns `users` and workspaces owns `workspaces` (with all their
+ * columns and their own migrations); these stubs exist so that:
+ *
+ *  - the generated migration can emit the cross-context FKs
+ *    `saved_views.owner_id → users(id)` and
+ *    `saved_views.workspace_id → workspaces(id)` — the host applies identity's
+ *    and workspaces' migrations before this plugin's, so both physical tables
+ *    already exist when this one runs; and
+ *  - `drizzle-kit generate` bundles a **pure-Drizzle** schema graph. Importing
+ *    either runtime barrel here would pull NestJS providers into drizzle-kit's
+ *    esbuild pass, which has no `experimentalDecorators` and fails on their
+ *    parameter decorators.
+ *
+ * Deliberately **not** re-exported from `schema/index.ts`, so drizzle-kit
+ * references them only in the FKs and never emits a duplicate `CREATE TABLE`.
+ */
+export declare const users: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "users";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "users";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+/** @see users — same reference-only rationale, for the workspaces table. */
+export declare const workspaces: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "workspaces";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "workspaces";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+//# sourceMappingURL=external-refs.d.ts.map

package/dist/lib/views/infrastructure/schema/external-refs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"external-refs.d.ts","sourceRoot":"","sources":["../../../../../src/lib/views/infrastructure/schema/external-refs.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;EAEhB,CAAC;AAEH,4EAA4E;AAC5E,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;EAErB,CAAC"}

package/dist/lib/views/infrastructure/schema/external-refs.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workspaces = exports.users = void 0;
+const pg_core_1 = require("drizzle-orm/pg-core");
+/**
+ * Reference-only projections of the tables this feature's foreign keys target.
+ * Identity owns `users` and workspaces owns `workspaces` (with all their
+ * columns and their own migrations); these stubs exist so that:
+ *
+ *  - the generated migration can emit the cross-context FKs
+ *    `saved_views.owner_id → users(id)` and
+ *    `saved_views.workspace_id → workspaces(id)` — the host applies identity's
+ *    and workspaces' migrations before this plugin's, so both physical tables
+ *    already exist when this one runs; and
+ *  - `drizzle-kit generate` bundles a **pure-Drizzle** schema graph. Importing
+ *    either runtime barrel here would pull NestJS providers into drizzle-kit's
+ *    esbuild pass, which has no `experimentalDecorators` and fails on their
+ *    parameter decorators.
+ *
+ * Deliberately **not** re-exported from `schema/index.ts`, so drizzle-kit
+ * references them only in the FKs and never emits a duplicate `CREATE TABLE`.
+ */
+exports.users = (0, pg_core_1.pgTable)('users', {
+    id: (0, pg_core_1.uuid)('id').primaryKey()
+});
+/** @see users — same reference-only rationale, for the workspaces table. */
+exports.workspaces = (0, pg_core_1.pgTable)('workspaces', {
+    id: (0, pg_core_1.uuid)('id').primaryKey()
+});

package/dist/lib/views/infrastructure/schema/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The saved-views schema barrel — also the entry point `drizzle.config.ts`
+ * diffs. `external-refs.ts` is deliberately absent: those stubs exist only so
+ * the foreign keys resolve, and re-exporting them here would make drizzle-kit
+ * emit a duplicate `CREATE TABLE users`.
+ */
+export { savedViews, savedViewDefaults, viewVisibility } from './saved-views';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/views/infrastructure/schema/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/lib/views/infrastructure/schema/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,UAAU,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC"}

package/dist/lib/views/infrastructure/schema/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.viewVisibility = exports.savedViewDefaults = exports.savedViews = void 0;
+/**
+ * The saved-views schema barrel — also the entry point `drizzle.config.ts`
+ * diffs. `external-refs.ts` is deliberately absent: those stubs exist only so
+ * the foreign keys resolve, and re-exporting them here would make drizzle-kit
+ * emit a duplicate `CREATE TABLE users`.
+ */
+var saved_views_1 = require("./saved-views");
+Object.defineProperty(exports, "savedViews", { enumerable: true, get: function () { return saved_views_1.savedViews; } });
+Object.defineProperty(exports, "savedViewDefaults", { enumerable: true, get: function () { return saved_views_1.savedViewDefaults; } });
+Object.defineProperty(exports, "viewVisibility", { enumerable: true, get: function () { return saved_views_1.viewVisibility; } });

package/dist/lib/views/infrastructure/schema/saved-views.d.ts

@@ -0,0 +1,275 @@
+import type { SavedViewPayload } from '../../domain/saved-view';
+/** Who may see a saved view. Mirrors `VIEW_VISIBILITY` in the domain module. */
+export declare const viewVisibility: import("drizzle-orm/pg-core").PgEnum<[string, ...string[]]>;
+/**
+ * A named slice of a list — the filter, sort, columns and page size an editor
+ * returns to. Scoped to a workspace, keyed by the list it belongs to (`scope`,
+ * `content:<typeName>` today), and owned by the user who saved it.
+ *
+ * A view is a **bookmark, not a grant**: its payload is replayed through the
+ * ordinary list query with the reader's own permissions and workspace scope, so
+ * a shared view shows a narrower reader fewer rows, never more.
+ */
+export declare const savedViews: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "saved_views";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "saved_views";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        workspaceId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "workspace_id";
+            tableName: "saved_views";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        scope: import("drizzle-orm/pg-core").PgColumn<{
+            name: "scope";
+            tableName: "saved_views";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        ownerId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "owner_id";
+            tableName: "saved_views";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        visibility: import("drizzle-orm/pg-core").PgColumn<{
+            name: "visibility";
+            tableName: "saved_views";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        name: import("drizzle-orm/pg-core").PgColumn<{
+            name: "name";
+            tableName: "saved_views";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        payload: import("drizzle-orm/pg-core").PgColumn<{
+            name: "payload";
+            tableName: "saved_views";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: SavedViewPayload;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: SavedViewPayload;
+        }>;
+        position: import("drizzle-orm/pg-core").PgColumn<{
+            name: "position";
+            tableName: "saved_views";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "saved_views";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "saved_views";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+/**
+ * Which view a user lands on when they open a list with no explicit params.
+ *
+ * A table rather than an `isDefault` column because the choice is **personal**:
+ * one shared view may be one member's default and not another's, which a column
+ * on the view itself cannot express. `viewId` cascades, so deleting a view
+ * silently drops the defaults pointing at it instead of stranding them.
+ */
+export declare const savedViewDefaults: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "saved_view_defaults";
+    schema: undefined;
+    columns: {
+        userId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "user_id";
+            tableName: "saved_view_defaults";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        scope: import("drizzle-orm/pg-core").PgColumn<{
+            name: "scope";
+            tableName: "saved_view_defaults";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        viewId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "view_id";
+            tableName: "saved_view_defaults";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "saved_view_defaults";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+//# sourceMappingURL=saved-views.d.ts.map

package/dist/lib/views/infrastructure/schema/saved-views.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"saved-views.d.ts","sourceRoot":"","sources":["../../../../../src/lib/views/infrastructure/schema/saved-views.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAGhE,gFAAgF;AAChF,eAAO,MAAM,cAAc,6DAG1B,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmDtB,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyB7B,CAAC"}

package/dist/lib/views/infrastructure/schema/saved-views.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.savedViewDefaults = exports.savedViews = exports.viewVisibility = void 0;
+const pg_core_1 = require("drizzle-orm/pg-core");
+const external_refs_1 = require("./external-refs");
+const saved_view_1 = require("../../domain/saved-view");
+/** Who may see a saved view. Mirrors `VIEW_VISIBILITY` in the domain module. */
+exports.viewVisibility = (0, pg_core_1.pgEnum)('view_visibility', saved_view_1.VIEW_VISIBILITY_VALUES);
+/**
+ * A named slice of a list — the filter, sort, columns and page size an editor
+ * returns to. Scoped to a workspace, keyed by the list it belongs to (`scope`,
+ * `content:<typeName>` today), and owned by the user who saved it.
+ *
+ * A view is a **bookmark, not a grant**: its payload is replayed through the
+ * ordinary list query with the reader's own permissions and workspace scope, so
+ * a shared view shows a narrower reader fewer rows, never more.
+ */
+exports.savedViews = (0, pg_core_1.pgTable)('saved_views', {
+    /** Primary key. */
+    id: (0, pg_core_1.uuid)('id').primaryKey().defaultRandom(),
+    /** The workspace this view belongs to. */
+    workspaceId: (0, pg_core_1.uuid)('workspace_id')
+        .notNull()
+        .references(() => external_refs_1.workspaces.id, { onDelete: 'cascade' }),
+    /** The list this view is over (`content:<typeName>`). */
+    scope: (0, pg_core_1.text)('scope').notNull(),
+    /** The user who saved it. */
+    ownerId: (0, pg_core_1.uuid)('owner_id')
+        .notNull()
+        .references(() => external_refs_1.users.id, { onDelete: 'cascade' }),
+    /** `private` (owner only) or `workspace` (every member). */
+    visibility: (0, exports.viewVisibility)('visibility').notNull().default('private'),
+    /** Display name. */
+    name: (0, pg_core_1.text)('name').notNull(),
+    /** The slice this view restores. @see SavedViewPayload */
+    payload: (0, pg_core_1.jsonb)('payload').$type().notNull(),
+    /** Manual ordering within its scope; ties break on `createdAt`. */
+    position: (0, pg_core_1.integer)('position').notNull().default(0),
+    /** Row creation timestamp. */
+    createdAt: (0, pg_core_1.timestamp)('created_at', { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+    /** Last-modified timestamp; refreshed on every update. */
+    updatedAt: (0, pg_core_1.timestamp)('updated_at', { withTimezone: true })
+        .notNull()
+        .defaultNow()
+        .$onUpdate(() => new Date())
+}, (table) => [
+    // The list query's shape: every view in one workspace + scope, both
+    // the caller's private ones and the workspace-visible ones.
+    (0, pg_core_1.index)('saved_views_workspace_scope_idx').on(table.workspaceId, table.scope),
+    // A person's own view names are unique per list, so "Save as new" with
+    // an existing name is a clean 409 rather than a second, indistinguishable
+    // row in the switcher. Scoped to the owner: two people may each have a
+    // "Needs review".
+    (0, pg_core_1.unique)('saved_views_owner_name_unique').on(table.workspaceId, table.scope, table.ownerId, table.name)
+]);
+/**
+ * Which view a user lands on when they open a list with no explicit params.
+ *
+ * A table rather than an `isDefault` column because the choice is **personal**:
+ * one shared view may be one member's default and not another's, which a column
+ * on the view itself cannot express. `viewId` cascades, so deleting a view
+ * silently drops the defaults pointing at it instead of stranding them.
+ */
+exports.savedViewDefaults = (0, pg_core_1.pgTable)('saved_view_defaults', {
+    /** The user whose default this is. */
+    userId: (0, pg_core_1.uuid)('user_id')
+        .notNull()
+        .references(() => external_refs_1.users.id, { onDelete: 'cascade' }),
+    /** The list the default applies to. */
+    scope: (0, pg_core_1.text)('scope').notNull(),
+    /** The view to open. */
+    viewId: (0, pg_core_1.uuid)('view_id')
+        .notNull()
+        .references(() => exports.savedViews.id, { onDelete: 'cascade' }),
+    /** Last-modified timestamp. */
+    updatedAt: (0, pg_core_1.timestamp)('updated_at', { withTimezone: true })
+        .notNull()
+        .defaultNow()
+        .$onUpdate(() => new Date())
+}, (table) => [
+    // One default per user per list.
+    (0, pg_core_1.primaryKey)({ columns: [table.userId, table.scope] }),
+    // Covers the cascade probe when a view is deleted.
+    (0, pg_core_1.index)('saved_view_defaults_view_id_idx').on(table.viewId)
+]);

package/dist/lib/views/views.constants.d.ts

@@ -0,0 +1,26 @@
+/** Limits and scope rules for saved list views. */
+/** Longest accepted view name. */
+export declare const VIEW_NAME_MAX_LENGTH = 80;
+/**
+ * Longest accepted `scope` key. A scope names the list a view belongs to —
+ * `content:<typeName>` today, `users:members` when the switcher reaches the
+ * other list pages. Kept generous enough for a long content-type name.
+ */
+export declare const VIEW_SCOPE_MAX_LENGTH = 128;
+/**
+ * The scopes this endpoint accepts, as a prefix. v1 only serves content
+ * collections; anything else is refused at the DTO so a typo can't quietly
+ * create a view nothing will ever read.
+ */
+export declare const CONTENT_SCOPE_PREFIX = "content:";
+/** Max columns a payload may pin — bounds the stored array. */
+export declare const VIEW_MAX_COLUMNS = 100;
+/** Max length of one column id inside a payload. */
+export declare const VIEW_COLUMN_MAX_LENGTH = 128;
+/** Max slot-owned list params (`extra`) a payload may carry. */
+export declare const VIEW_MAX_EXTRA_KEYS = 20;
+/** Max length of an `extra` key or value. */
+export declare const VIEW_EXTRA_MAX_LENGTH = 255;
+/** Max saved views one user may hold in a single workspace + scope. */
+export declare const VIEW_MAX_PER_SCOPE = 100;
+//# sourceMappingURL=views.constants.d.ts.map

package/dist/lib/views/views.constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"views.constants.d.ts","sourceRoot":"","sources":["../../../src/lib/views/views.constants.ts"],"names":[],"mappings":"AAAA,mDAAmD;AAEnD,kCAAkC;AAClC,eAAO,MAAM,oBAAoB,KAAK,CAAC;AAEvC;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,MAAM,CAAC;AAEzC;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,aAAa,CAAC;AAE/C,+DAA+D;AAC/D,eAAO,MAAM,gBAAgB,MAAM,CAAC;AAEpC,oDAAoD;AACpD,eAAO,MAAM,sBAAsB,MAAM,CAAC;AAE1C,gEAAgE;AAChE,eAAO,MAAM,mBAAmB,KAAK,CAAC;AAEtC,6CAA6C;AAC7C,eAAO,MAAM,qBAAqB,MAAM,CAAC;AAEzC,uEAAuE;AACvE,eAAO,MAAM,kBAAkB,MAAM,CAAC"}