@kernhq/module-quire 0.7.4 → 0.9.0

package/dist/server/_impl.d.ts

@@ -1487,6 +1487,249 @@ export declare function implement_(kernel: Kernel): {
                 }, import("zod/v4/core").$strip>;
             };
         }>>, Record<never, never>>;
+        list: import("@orpc/server").Procedure<import("@orpc/server").MergedInitialContext<RequestContext & Record<never, never>, RequestContext & Record<never, never> & Omit<RequestContext & Record<never, never>, keyof RequestContext> & Omit<RequestContext & Record<never, never>, "workspaceId" | "kernel" | "principal" | "requestId" | "ip" | "headers">, RequestContext>, Omit<import("@orpc/server").MergedCurrentContext<RequestContext, {
+            workspaceId: string;
+            kernel: Kernel;
+            principal: import("@kernhq/contracts").Principal;
+            requestId: string;
+            ip: string;
+            headers: Record<string, string | string[] | undefined>;
+        }>, never> & Record<never, never>, import("zod").ZodObject<{
+            workspaceId: import("zod/v4/core").$ZodBranded<import("zod").ZodUUID, "WorkspaceId", "out">;
+            spaceId: import("zod").ZodUUID;
+        }, import("zod/v4/core").$strip>, import("zod").ZodArray<import("zod").ZodObject<{
+            id: import("zod").ZodUUID;
+            pageId: import("zod").ZodUUID;
+            name: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>>, import("@orpc/server").MergedErrorMap<Record<never, never>, import("@orpc/server").MergedErrorMap<Record<never, never>, {
+            BAD_REQUEST: {
+                data: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+            };
+            UNAUTHORIZED: {};
+            FORBIDDEN: {
+                data: import("zod").ZodOptional<import("zod").ZodObject<{
+                    permission: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>>;
+            };
+            NOT_FOUND: {};
+            CONFLICT: {
+                data: import("zod").ZodOptional<import("zod").ZodObject<{
+                    reason: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>>;
+            };
+            RATE_LIMITED: {};
+            MODULE_DISABLED: {
+                data: import("zod").ZodObject<{
+                    module: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+            };
+        }>>, Record<never, never>>;
+        forPage: import("@orpc/server").Procedure<import("@orpc/server").MergedInitialContext<RequestContext & Record<never, never>, RequestContext & Record<never, never> & Omit<RequestContext & Record<never, never>, keyof RequestContext> & Omit<RequestContext & Record<never, never>, "workspaceId" | "kernel" | "principal" | "requestId" | "ip" | "headers">, RequestContext>, Omit<import("@orpc/server").MergedCurrentContext<RequestContext, {
+            workspaceId: string;
+            kernel: Kernel;
+            principal: import("@kernhq/contracts").Principal;
+            requestId: string;
+            ip: string;
+            headers: Record<string, string | string[] | undefined>;
+        }>, never> & Record<never, never>, import("zod").ZodObject<{
+            workspaceId: import("zod/v4/core").$ZodBranded<import("zod").ZodUUID, "WorkspaceId", "out">;
+            pageId: import("zod").ZodUUID;
+        }, import("zod/v4/core").$strip>, import("zod").ZodNullable<import("zod").ZodObject<{
+            id: import("zod").ZodUUID;
+            workspaceId: import("zod").ZodString;
+            spaceId: import("zod").ZodUUID;
+            pageId: import("zod").ZodUUID;
+            name: import("zod").ZodString;
+            description: import("zod").ZodString;
+            inline: import("zod").ZodBoolean;
+            properties: import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodUUID;
+                databaseId: import("zod").ZodUUID;
+                key: import("zod").ZodString;
+                name: import("zod").ZodString;
+                type: import("zod").ZodEnum<{
+                    number: "number";
+                    date: "date";
+                    email: "email";
+                    text: "text";
+                    select: "select";
+                    multi_select: "multi_select";
+                    status: "status";
+                    person: "person";
+                    files: "files";
+                    checkbox: "checkbox";
+                    url: "url";
+                    phone: "phone";
+                    relation: "relation";
+                    rollup: "rollup";
+                    formula: "formula";
+                    created_time: "created_time";
+                    created_by: "created_by";
+                    edited_time: "edited_time";
+                    edited_by: "edited_by";
+                }>;
+                config: import("zod").ZodObject<{
+                    options: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                        id: import("zod").ZodString;
+                        label: import("zod").ZodString;
+                        colour: import("zod").ZodDefault<import("zod").ZodString>;
+                        group: import("zod").ZodOptional<import("zod").ZodEnum<{
+                            todo: "todo";
+                            doing: "doing";
+                            done: "done";
+                        }>>;
+                    }, import("zod/v4/core").$strip>>>;
+                    format: import("zod").ZodOptional<import("zod").ZodString>;
+                    precision: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    includeTime: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    isRange: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    relationDatabaseId: import("zod").ZodOptional<import("zod").ZodUUID>;
+                    relationPropertyId: import("zod").ZodOptional<import("zod").ZodUUID>;
+                    rollupRelationPropertyId: import("zod").ZodOptional<import("zod").ZodUUID>;
+                    rollupTargetPropertyId: import("zod").ZodOptional<import("zod").ZodUUID>;
+                    rollupFunction: import("zod").ZodOptional<import("zod").ZodEnum<{
+                        count: "count";
+                        count_values: "count_values";
+                        count_unique: "count_unique";
+                        sum: "sum";
+                        average: "average";
+                        min: "min";
+                        max: "max";
+                        range: "range";
+                        show_original: "show_original";
+                        checked: "checked";
+                        unchecked: "unchecked";
+                        percent_checked: "percent_checked";
+                    }>>;
+                    expression: import("zod").ZodOptional<import("zod").ZodString>;
+                    multiple: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                }, import("zod/v4/core").$strip>;
+                position: import("zod").ZodString;
+                hidden: import("zod").ZodBoolean;
+            }, import("zod/v4/core").$strip>>;
+            views: import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodUUID;
+                databaseId: import("zod").ZodUUID;
+                name: import("zod").ZodString;
+                kind: import("zod").ZodEnum<{
+                    table: "table";
+                    board: "board";
+                    calendar: "calendar";
+                    gallery: "gallery";
+                    list: "list";
+                    timeline: "timeline";
+                }>;
+                config: import("zod").ZodObject<{
+                    filters: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+                        propertyKey: import("zod").ZodString;
+                        operator: import("zod").ZodEnum<{
+                            equals: "equals";
+                            not_equals: "not_equals";
+                            contains: "contains";
+                            not_contains: "not_contains";
+                            starts_with: "starts_with";
+                            ends_with: "ends_with";
+                            is_empty: "is_empty";
+                            is_not_empty: "is_not_empty";
+                            greater_than: "greater_than";
+                            less_than: "less_than";
+                            on_or_before: "on_or_before";
+                            on_or_after: "on_or_after";
+                            is_any_of: "is_any_of";
+                            is_none_of: "is_none_of";
+                        }>;
+                        value: import("zod").ZodOptional<import("zod").ZodUnknown>;
+                    }, import("zod/v4/core").$strip>>>;
+                    filterMode: import("zod").ZodDefault<import("zod").ZodEnum<{
+                        and: "and";
+                        or: "or";
+                    }>>;
+                    sorts: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+                        propertyKey: import("zod").ZodString;
+                        direction: import("zod").ZodDefault<import("zod").ZodEnum<{
+                            asc: "asc";
+                            desc: "desc";
+                        }>>;
+                    }, import("zod/v4/core").$strip>>>;
+                    groupBy: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodString>>;
+                    dateProperty: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodString>>;
+                    visibleProperties: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodArray<import("zod").ZodString>>>;
+                    columnWidths: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodNumber>>;
+                    cardSize: import("zod").ZodDefault<import("zod").ZodEnum<{
+                        small: "small";
+                        medium: "medium";
+                        large: "large";
+                    }>>;
+                    coverProperty: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodString>>;
+                }, import("zod/v4/core").$strip>;
+                position: import("zod").ZodString;
+                isDefault: import("zod").ZodBoolean;
+            }, import("zod/v4/core").$strip>>;
+            createdAt: import("zod").ZodISODateTime;
+            updatedAt: import("zod").ZodISODateTime;
+        }, import("zod/v4/core").$strip>>, import("@orpc/server").MergedErrorMap<Record<never, never>, import("@orpc/server").MergedErrorMap<Record<never, never>, {
+            BAD_REQUEST: {
+                data: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+            };
+            UNAUTHORIZED: {};
+            FORBIDDEN: {
+                data: import("zod").ZodOptional<import("zod").ZodObject<{
+                    permission: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>>;
+            };
+            NOT_FOUND: {};
+            CONFLICT: {
+                data: import("zod").ZodOptional<import("zod").ZodObject<{
+                    reason: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>>;
+            };
+            RATE_LIMITED: {};
+            MODULE_DISABLED: {
+                data: import("zod").ZodObject<{
+                    module: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+            };
+        }>>, Record<never, never>>;
+        lookup: import("@orpc/server").Procedure<import("@orpc/server").MergedInitialContext<RequestContext & Record<never, never>, RequestContext & Record<never, never> & Omit<RequestContext & Record<never, never>, keyof RequestContext> & Omit<RequestContext & Record<never, never>, "workspaceId" | "kernel" | "principal" | "requestId" | "ip" | "headers">, RequestContext>, Omit<import("@orpc/server").MergedCurrentContext<RequestContext, {
+            workspaceId: string;
+            kernel: Kernel;
+            principal: import("@kernhq/contracts").Principal;
+            requestId: string;
+            ip: string;
+            headers: Record<string, string | string[] | undefined>;
+        }>, never> & Record<never, never>, import("zod").ZodObject<{
+            workspaceId: import("zod/v4/core").$ZodBranded<import("zod").ZodUUID, "WorkspaceId", "out">;
+            databaseId: import("zod").ZodUUID;
+            query: import("zod").ZodDefault<import("zod").ZodString>;
+            ids: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodUUID>>;
+            limit: import("zod").ZodDefault<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodArray<import("zod").ZodObject<{
+            id: import("zod").ZodUUID;
+            title: import("zod").ZodString;
+            icon: import("zod").ZodNullable<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>, import("@orpc/server").MergedErrorMap<Record<never, never>, import("@orpc/server").MergedErrorMap<Record<never, never>, {
+            BAD_REQUEST: {
+                data: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+            };
+            UNAUTHORIZED: {};
+            FORBIDDEN: {
+                data: import("zod").ZodOptional<import("zod").ZodObject<{
+                    permission: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>>;
+            };
+            NOT_FOUND: {};
+            CONFLICT: {
+                data: import("zod").ZodOptional<import("zod").ZodObject<{
+                    reason: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>>;
+            };
+            RATE_LIMITED: {};
+            MODULE_DISABLED: {
+                data: import("zod").ZodObject<{
+                    module: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+            };
+        }>>, Record<never, never>>;
         create: import("@orpc/server").Procedure<import("@orpc/server").MergedInitialContext<RequestContext & Record<never, never>, RequestContext & Record<never, never> & Omit<RequestContext & Record<never, never>, keyof RequestContext> & Omit<RequestContext & Record<never, never>, "workspaceId" | "kernel" | "principal" | "requestId" | "ip" | "headers">, RequestContext>, Omit<import("@orpc/server").MergedCurrentContext<RequestContext, {
             workspaceId: string;
             kernel: Kernel;
@@ -2110,6 +2353,104 @@ export declare function implement_(kernel: Kernel): {
                 }, import("zod/v4/core").$strip>;
             };
         }>>, Record<never, never>>;
+        moveProperty: import("@orpc/server").Procedure<import("@orpc/server").MergedInitialContext<RequestContext & Record<never, never>, RequestContext & Record<never, never> & Omit<RequestContext & Record<never, never>, keyof RequestContext> & Omit<RequestContext & Record<never, never>, "workspaceId" | "kernel" | "principal" | "requestId" | "ip" | "headers">, RequestContext>, Omit<import("@orpc/server").MergedCurrentContext<RequestContext, {
+            workspaceId: string;
+            kernel: Kernel;
+            principal: import("@kernhq/contracts").Principal;
+            requestId: string;
+            ip: string;
+            headers: Record<string, string | string[] | undefined>;
+        }>, never> & Record<never, never>, import("zod").ZodObject<{
+            workspaceId: import("zod/v4/core").$ZodBranded<import("zod").ZodUUID, "WorkspaceId", "out">;
+            propertyId: import("zod").ZodUUID;
+            afterId: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodUUID>>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            id: import("zod").ZodUUID;
+            databaseId: import("zod").ZodUUID;
+            key: import("zod").ZodString;
+            name: import("zod").ZodString;
+            type: import("zod").ZodEnum<{
+                number: "number";
+                date: "date";
+                email: "email";
+                text: "text";
+                select: "select";
+                multi_select: "multi_select";
+                status: "status";
+                person: "person";
+                files: "files";
+                checkbox: "checkbox";
+                url: "url";
+                phone: "phone";
+                relation: "relation";
+                rollup: "rollup";
+                formula: "formula";
+                created_time: "created_time";
+                created_by: "created_by";
+                edited_time: "edited_time";
+                edited_by: "edited_by";
+            }>;
+            config: import("zod").ZodObject<{
+                options: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                    id: import("zod").ZodString;
+                    label: import("zod").ZodString;
+                    colour: import("zod").ZodDefault<import("zod").ZodString>;
+                    group: import("zod").ZodOptional<import("zod").ZodEnum<{
+                        todo: "todo";
+                        doing: "doing";
+                        done: "done";
+                    }>>;
+                }, import("zod/v4/core").$strip>>>;
+                format: import("zod").ZodOptional<import("zod").ZodString>;
+                precision: import("zod").ZodOptional<import("zod").ZodNumber>;
+                includeTime: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                isRange: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                relationDatabaseId: import("zod").ZodOptional<import("zod").ZodUUID>;
+                relationPropertyId: import("zod").ZodOptional<import("zod").ZodUUID>;
+                rollupRelationPropertyId: import("zod").ZodOptional<import("zod").ZodUUID>;
+                rollupTargetPropertyId: import("zod").ZodOptional<import("zod").ZodUUID>;
+                rollupFunction: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    count: "count";
+                    count_values: "count_values";
+                    count_unique: "count_unique";
+                    sum: "sum";
+                    average: "average";
+                    min: "min";
+                    max: "max";
+                    range: "range";
+                    show_original: "show_original";
+                    checked: "checked";
+                    unchecked: "unchecked";
+                    percent_checked: "percent_checked";
+                }>>;
+                expression: import("zod").ZodOptional<import("zod").ZodString>;
+                multiple: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            }, import("zod/v4/core").$strip>;
+            position: import("zod").ZodString;
+            hidden: import("zod").ZodBoolean;
+        }, import("zod/v4/core").$strip>, import("@orpc/server").MergedErrorMap<Record<never, never>, import("@orpc/server").MergedErrorMap<Record<never, never>, {
+            BAD_REQUEST: {
+                data: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+            };
+            UNAUTHORIZED: {};
+            FORBIDDEN: {
+                data: import("zod").ZodOptional<import("zod").ZodObject<{
+                    permission: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>>;
+            };
+            NOT_FOUND: {};
+            CONFLICT: {
+                data: import("zod").ZodOptional<import("zod").ZodObject<{
+                    reason: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>>;
+            };
+            RATE_LIMITED: {};
+            MODULE_DISABLED: {
+                data: import("zod").ZodObject<{
+                    module: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+            };
+        }>>, Record<never, never>>;
         removeProperty: import("@orpc/server").Procedure<import("@orpc/server").MergedInitialContext<RequestContext & Record<never, never>, RequestContext & Record<never, never> & Omit<RequestContext & Record<never, never>, keyof RequestContext> & Omit<RequestContext & Record<never, never>, "workspaceId" | "kernel" | "principal" | "requestId" | "ip" | "headers">, RequestContext>, Omit<import("@orpc/server").MergedCurrentContext<RequestContext, {
             workspaceId: string;
             kernel: Kernel;

package/dist/server/_impl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"_impl.d.ts","sourceRoot":"","sources":["../../src/server/_impl.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,kBAAkB,EAElB,KAAK,MAAM,EACX,cAAc,EACd,KAAK,cAAc,EAGpB,MAAM,gBAAgB,CAAA;AASvB;;;;;;;GAOG;AACH,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,cAAc,EAAE,CAAA;AAI3D,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4lBxC"}
+{"version":3,"file":"_impl.d.ts","sourceRoot":"","sources":["../../src/server/_impl.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,kBAAkB,EAElB,KAAK,MAAM,EACX,cAAc,EACd,KAAK,cAAc,EAGpB,MAAM,gBAAgB,CAAA;AASvB;;;;;;;GAOG;AACH,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,cAAc,EAAE,CAAA;AAI3D,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmrBxC"}

package/dist/server/_impl.js

@@ -287,6 +287,26 @@ export function implement_(kernel) {
             get: scoped.databases.get
                 .use(requires('quire.page.view'))
                 .handler(({ input, context }) => run(context, input.workspaceId, (tx) => svc.databases.get(tx, input.workspaceId, input.databaseId))),
+            list: scoped.databases.list.use(requires('quire.page.view')).handler(({ input, context }) => run(context, input.workspaceId, async (tx) => {
+                await svc.access.spaceRow(tx, input.workspaceId, input.spaceId);
+                await svc.access.requireSpace(context.principal, 'quire.space.view', input.workspaceId, input.spaceId);
+                return svc.databases.list(tx, input.workspaceId, input.spaceId);
+            })),
+            forPage: scoped.databases.forPage.use(requires('quire.page.view')).handler(({ input, context }) => run(context, input.workspaceId, async (tx) => {
+                const scope = await svc.access.scopeOf(tx, input.workspaceId, input.pageId);
+                await svc.access.requirePage(context.principal, 'quire.page.view', input.workspaceId, scope);
+                return svc.databases.forPage(tx, input.workspaceId, input.pageId);
+            })),
+            lookup: scoped.databases.lookup.use(requires('quire.page.view')).handler(({ input, context }) => run(context, input.workspaceId, async (tx) => {
+                const db = await svc.databases.get(tx, input.workspaceId, input.databaseId);
+                const scope = await svc.access.scopeOf(tx, input.workspaceId, db.pageId);
+                await svc.access.requirePage(context.principal, 'quire.page.view', input.workspaceId, scope);
+                return svc.databases.lookup(tx, input.workspaceId, input.databaseId, {
+                    query: input.query,
+                    ids: input.ids,
+                    limit: input.limit,
+                });
+            })),
             create: scoped.databases.create.use(requires('quire.page.edit')).handler(async ({ input, context }) => {
                 const db = await run(context, input.workspaceId, async (tx) => {
                     const scope = await svc.access.scopeOf(tx, input.workspaceId, input.pageId);
@@ -343,8 +363,29 @@ export function implement_(kernel) {
                         await svc.pages.update(tx, context.principal, input.workspaceId, input.rowId, {
                             title: input.title,
                         });
-                    if (input.props)
-                        await svc.databases.setRowFields(tx, input.workspaceId, input.rowId, null, input.props);
+                    /**
+                     * A relation cell edited from a table arrives in `props` like any other, and writing it
+                     * there would leave the join table — which is what a rollup walks and what the other
+                     * side reads — untouched. Split those keys out and route them through `setRelation`, so
+                     * the two stores cannot diverge whichever surface did the editing.
+                     */
+                    if (input.props) {
+                        const row = await svc.databases.rowById(tx, input.workspaceId, input.rowId);
+                        const db = row.databaseId
+                            ? await svc.databases.get(tx, input.workspaceId, row.databaseId)
+                            : null;
+                        const relationProps = (db?.properties ?? []).filter((p) => p.type === 'relation');
+                        const plain = {};
+                        for (const [key, value] of Object.entries(input.props)) {
+                            const relation = relationProps.find((p) => p.key === key);
+                            if (relation)
+                                await svc.databases.setRelation(tx, input.workspaceId, relation.id, input.rowId, (Array.isArray(value) ? value : value == null ? [] : [value]).map(String));
+                            else
+                                plain[key] = value;
+                        }
+                        if (Object.keys(plain).length > 0)
+                            await svc.databases.setRowFields(tx, input.workspaceId, input.rowId, null, plain);
+                    }
                     await svc.databases.recompute(tx, input.workspaceId, input.rowId);
                     // Anything rolling this row up is now stale.
                     for (const id of await svc.databases.dependentsOf(tx, input.workspaceId, input.rowId))
@@ -354,34 +395,62 @@ export function implement_(kernel) {
                 await announce(input.workspaceId, 'row', row.id, 'updated', { databaseId: row.databaseId });
                 return row;
             }),
+            /**
+             * Every schema change announces `database`.
+             *
+             * Adding a column, hiding one, or adding a view changes what *every* open tab of this
+             * database is drawing, and none of these announced anything — so a second person's table kept
+             * the old columns until they reloaded, which reads as their edit having been lost.
+             */
             addProperty: scoped.databases.addProperty
                 .use(requires('quire.page.edit'))
-                .handler(({ input, context }) => run(context, input.workspaceId, (tx) => svc.databases.addProperty(tx, input.workspaceId, input.databaseId, input))),
+                .handler(async ({ input, context }) => {
+                const property = await run(context, input.workspaceId, (tx) => svc.databases.addProperty(tx, input.workspaceId, input.databaseId, input));
+                await announce(input.workspaceId, 'database', input.databaseId, 'updated');
+                return property;
+            }),
             updateProperty: scoped.databases.updateProperty
                 .use(requires('quire.page.edit'))
-                .handler(({ input, context }) => {
+                .handler(async ({ input, context }) => {
                 const { workspaceId, propertyId, ...patch } = input;
-                return run(context, workspaceId, (tx) => svc.databases.updateProperty(tx, workspaceId, propertyId, patch));
+                const property = await run(context, workspaceId, (tx) => svc.databases.updateProperty(tx, workspaceId, propertyId, patch));
+                await announce(workspaceId, 'database', property.databaseId, 'updated');
+                return property;
+            }),
+            moveProperty: scoped.databases.moveProperty
+                .use(requires('quire.page.edit'))
+                .handler(async ({ input, context }) => {
+                const property = await run(context, input.workspaceId, (tx) => svc.databases.moveProperty(tx, input.workspaceId, input.propertyId, input.afterId));
+                await announce(input.workspaceId, 'database', property.databaseId, 'updated');
+                return property;
             }),
             removeProperty: scoped.databases.removeProperty
                 .use(requires('quire.page.edit'))
                 .handler(async ({ input, context }) => {
-                await run(context, input.workspaceId, (tx) => svc.databases.removeProperty(tx, input.workspaceId, input.propertyId));
+                const property = await run(context, input.workspaceId, (tx) => svc.databases.removeProperty(tx, input.workspaceId, input.propertyId));
+                await announce(input.workspaceId, 'database', property.databaseId, 'updated');
                 return { ok: true };
             }),
             addView: scoped.databases.addView
                 .use(requires('quire.page.edit'))
-                .handler(({ input, context }) => run(context, input.workspaceId, (tx) => svc.databases.addView(tx, input.workspaceId, input.databaseId, input))),
+                .handler(async ({ input, context }) => {
+                const view = await run(context, input.workspaceId, (tx) => svc.databases.addView(tx, input.workspaceId, input.databaseId, input));
+                await announce(input.workspaceId, 'database', input.databaseId, 'updated');
+                return view;
+            }),
             updateView: scoped.databases.updateView
                 .use(requires('quire.page.edit'))
-                .handler(({ input, context }) => {
+                .handler(async ({ input, context }) => {
                 const { workspaceId, viewId, ...patch } = input;
-                return run(context, workspaceId, (tx) => svc.databases.updateView(tx, workspaceId, viewId, patch));
+                const view = await run(context, workspaceId, (tx) => svc.databases.updateView(tx, workspaceId, viewId, patch));
+                await announce(workspaceId, 'database', view.databaseId, 'updated');
+                return view;
             }),
             removeView: scoped.databases.removeView
                 .use(requires('quire.page.edit'))
                 .handler(async ({ input, context }) => {
-                await run(context, input.workspaceId, (tx) => svc.databases.removeView(tx, input.workspaceId, input.viewId));
+                const view = await run(context, input.workspaceId, (tx) => svc.databases.removeView(tx, input.workspaceId, input.viewId));
+                await announce(input.workspaceId, 'database', view.databaseId, 'updated');
                 return { ok: true };
             }),
             setRelation: scoped.databases.setRelation