@kernhq/module-quire 0.4.1 → 0.5.0

package/dist/contract/index.d.ts

@@ -3,5 +3,6 @@ export * from './events.js';
 export * from './models.js';
 export * from './notifications.js';
 export * from './permissions.js';
+export * from './properties.js';
 export * from './router.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/contract/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/contract/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA;AACjC,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA;AAC3B,cAAc,oBAAoB,CAAA;AAClC,cAAc,kBAAkB,CAAA;AAChC,cAAc,aAAa,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/contract/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA;AACjC,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA;AAC3B,cAAc,oBAAoB,CAAA;AAClC,cAAc,kBAAkB,CAAA;AAChC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,aAAa,CAAA"}

package/dist/contract/index.js

@@ -3,5 +3,6 @@ export * from './events.js';
 export * from './models.js';
 export * from './notifications.js';
 export * from './permissions.js';
+export * from './properties.js';
 export * from './router.js';
 //# sourceMappingURL=index.js.map

package/dist/contract/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/contract/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA;AACjC,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA;AAC3B,cAAc,oBAAoB,CAAA;AAClC,cAAc,kBAAkB,CAAA;AAChC,cAAc,aAAa,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/contract/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA;AACjC,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA;AAC3B,cAAc,oBAAoB,CAAA;AAClC,cAAc,kBAAkB,CAAA;AAChC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,aAAa,CAAA"}

package/dist/contract/properties.d.ts

@@ -0,0 +1,483 @@
+import { z } from 'zod';
+/**
+ * What a column can be.
+ *
+ * The set is closed on purpose. A property type is not just a input widget: it decides how a value
+ * sorts, what a filter can ask of it, and whether a rollup can add it up. An open set would mean a
+ * table view that can display something no filter can find.
+ */
+export declare const PropertyType: z.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";
+}>;
+export type PropertyType = z.infer<typeof PropertyType>;
+/** A choice in a select, a multi-select or a status. */
+export declare const SelectOption: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    colour: z.ZodDefault<z.ZodString>;
+    group: z.ZodOptional<z.ZodEnum<{
+        todo: "todo";
+        doing: "doing";
+        done: "done";
+    }>>;
+}, z.core.$strip>;
+export type SelectOption = z.infer<typeof SelectOption>;
+/** How a rollup reduces the values it gathers from the other side of a relation. */
+export declare const RollupFunction: z.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";
+}>;
+export type RollupFunction = z.infer<typeof RollupFunction>;
+/**
+ * Everything a type needs beyond its name.
+ *
+ * One permissive object rather than a discriminated union per type: the union would have to be
+ * exhaustive at every boundary, and a column's configuration is read by code that already knows
+ * which type it is holding. What matters is that adding a type never needs a migration.
+ */
+export declare const PropertyConfig: z.ZodObject<{
+    options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        colour: z.ZodDefault<z.ZodString>;
+        group: z.ZodOptional<z.ZodEnum<{
+            todo: "todo";
+            doing: "doing";
+            done: "done";
+        }>>;
+    }, z.core.$strip>>>;
+    format: z.ZodOptional<z.ZodString>;
+    precision: z.ZodOptional<z.ZodNumber>;
+    includeTime: z.ZodOptional<z.ZodBoolean>;
+    isRange: z.ZodOptional<z.ZodBoolean>;
+    relationDatabaseId: z.ZodOptional<z.ZodUUID>;
+    relationPropertyId: z.ZodOptional<z.ZodUUID>;
+    rollupRelationPropertyId: z.ZodOptional<z.ZodUUID>;
+    rollupTargetPropertyId: z.ZodOptional<z.ZodUUID>;
+    rollupFunction: z.ZodOptional<z.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: z.ZodOptional<z.ZodString>;
+    multiple: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type PropertyConfig = z.infer<typeof PropertyConfig>;
+export declare const Property: z.ZodObject<{
+    id: z.ZodUUID;
+    databaseId: z.ZodUUID;
+    key: z.ZodString;
+    name: z.ZodString;
+    type: z.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: z.ZodObject<{
+        options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            colour: z.ZodDefault<z.ZodString>;
+            group: z.ZodOptional<z.ZodEnum<{
+                todo: "todo";
+                doing: "doing";
+                done: "done";
+            }>>;
+        }, z.core.$strip>>>;
+        format: z.ZodOptional<z.ZodString>;
+        precision: z.ZodOptional<z.ZodNumber>;
+        includeTime: z.ZodOptional<z.ZodBoolean>;
+        isRange: z.ZodOptional<z.ZodBoolean>;
+        relationDatabaseId: z.ZodOptional<z.ZodUUID>;
+        relationPropertyId: z.ZodOptional<z.ZodUUID>;
+        rollupRelationPropertyId: z.ZodOptional<z.ZodUUID>;
+        rollupTargetPropertyId: z.ZodOptional<z.ZodUUID>;
+        rollupFunction: z.ZodOptional<z.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: z.ZodOptional<z.ZodString>;
+        multiple: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+    position: z.ZodString;
+    hidden: z.ZodBoolean;
+}, z.core.$strip>;
+export type Property = z.infer<typeof Property>;
+/**
+ * A cell.
+ *
+ * Deliberately loose: the shape depends on the column's type, and the server validates a value
+ * against its own property before it is written. Typing it here as a union would put the same
+ * exhaustive switch in every consumer that only ever renders one type at a time.
+ */
+export declare const PropertyValue: z.ZodUnknown;
+export declare const ViewKind: z.ZodEnum<{
+    table: "table";
+    board: "board";
+    calendar: "calendar";
+    gallery: "gallery";
+    list: "list";
+    timeline: "timeline";
+}>;
+export type ViewKind = z.infer<typeof ViewKind>;
+/** How a filter compares. Which of these a column accepts depends on its type. */
+export declare const FilterOperator: z.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";
+}>;
+export type FilterOperator = z.infer<typeof FilterOperator>;
+export declare const Filter: z.ZodObject<{
+    propertyKey: z.ZodString;
+    operator: z.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: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+export declare const Sort: z.ZodObject<{
+    propertyKey: z.ZodString;
+    direction: z.ZodDefault<z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>;
+}, z.core.$strip>;
+export declare const ViewConfig: z.ZodObject<{
+    filters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        propertyKey: z.ZodString;
+        operator: z.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: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>>>;
+    filterMode: z.ZodDefault<z.ZodEnum<{
+        and: "and";
+        or: "or";
+    }>>;
+    sorts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        propertyKey: z.ZodString;
+        direction: z.ZodDefault<z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>>;
+    }, z.core.$strip>>>;
+    groupBy: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    dateProperty: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    visibleProperties: z.ZodDefault<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    columnWidths: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    cardSize: z.ZodDefault<z.ZodEnum<{
+        small: "small";
+        medium: "medium";
+        large: "large";
+    }>>;
+    coverProperty: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type ViewConfig = z.infer<typeof ViewConfig>;
+export declare const View: z.ZodObject<{
+    id: z.ZodUUID;
+    databaseId: z.ZodUUID;
+    name: z.ZodString;
+    kind: z.ZodEnum<{
+        table: "table";
+        board: "board";
+        calendar: "calendar";
+        gallery: "gallery";
+        list: "list";
+        timeline: "timeline";
+    }>;
+    config: z.ZodObject<{
+        filters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            propertyKey: z.ZodString;
+            operator: z.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: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strip>>>;
+        filterMode: z.ZodDefault<z.ZodEnum<{
+            and: "and";
+            or: "or";
+        }>>;
+        sorts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            propertyKey: z.ZodString;
+            direction: z.ZodDefault<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strip>>>;
+        groupBy: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        dateProperty: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        visibleProperties: z.ZodDefault<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+        columnWidths: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        cardSize: z.ZodDefault<z.ZodEnum<{
+            small: "small";
+            medium: "medium";
+            large: "large";
+        }>>;
+        coverProperty: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>;
+    position: z.ZodString;
+    isDefault: z.ZodBoolean;
+}, z.core.$strip>;
+export type View = z.infer<typeof View>;
+export declare const Database: z.ZodObject<{
+    id: z.ZodUUID;
+    workspaceId: z.ZodString;
+    spaceId: z.ZodUUID;
+    pageId: z.ZodUUID;
+    name: z.ZodString;
+    description: z.ZodString;
+    inline: z.ZodBoolean;
+    properties: z.ZodArray<z.ZodObject<{
+        id: z.ZodUUID;
+        databaseId: z.ZodUUID;
+        key: z.ZodString;
+        name: z.ZodString;
+        type: z.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: z.ZodObject<{
+            options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                colour: z.ZodDefault<z.ZodString>;
+                group: z.ZodOptional<z.ZodEnum<{
+                    todo: "todo";
+                    doing: "doing";
+                    done: "done";
+                }>>;
+            }, z.core.$strip>>>;
+            format: z.ZodOptional<z.ZodString>;
+            precision: z.ZodOptional<z.ZodNumber>;
+            includeTime: z.ZodOptional<z.ZodBoolean>;
+            isRange: z.ZodOptional<z.ZodBoolean>;
+            relationDatabaseId: z.ZodOptional<z.ZodUUID>;
+            relationPropertyId: z.ZodOptional<z.ZodUUID>;
+            rollupRelationPropertyId: z.ZodOptional<z.ZodUUID>;
+            rollupTargetPropertyId: z.ZodOptional<z.ZodUUID>;
+            rollupFunction: z.ZodOptional<z.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: z.ZodOptional<z.ZodString>;
+            multiple: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>;
+        position: z.ZodString;
+        hidden: z.ZodBoolean;
+    }, z.core.$strip>>;
+    views: z.ZodArray<z.ZodObject<{
+        id: z.ZodUUID;
+        databaseId: z.ZodUUID;
+        name: z.ZodString;
+        kind: z.ZodEnum<{
+            table: "table";
+            board: "board";
+            calendar: "calendar";
+            gallery: "gallery";
+            list: "list";
+            timeline: "timeline";
+        }>;
+        config: z.ZodObject<{
+            filters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                propertyKey: z.ZodString;
+                operator: z.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: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>>>;
+            filterMode: z.ZodDefault<z.ZodEnum<{
+                and: "and";
+                or: "or";
+            }>>;
+            sorts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                propertyKey: z.ZodString;
+                direction: z.ZodDefault<z.ZodEnum<{
+                    asc: "asc";
+                    desc: "desc";
+                }>>;
+            }, z.core.$strip>>>;
+            groupBy: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            dateProperty: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            visibleProperties: z.ZodDefault<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+            columnWidths: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+            cardSize: z.ZodDefault<z.ZodEnum<{
+                small: "small";
+                medium: "medium";
+                large: "large";
+            }>>;
+            coverProperty: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>;
+        position: z.ZodString;
+        isDefault: z.ZodBoolean;
+    }, z.core.$strip>>;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export type Database = z.infer<typeof Database>;
+/** A row: the page, plus its cells and whatever the server computed from them. */
+export declare const Row: z.ZodObject<{
+    id: z.ZodUUID;
+    databaseId: z.ZodUUID;
+    title: z.ZodString;
+    icon: z.ZodNullable<z.ZodString>;
+    props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    computed: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    createdBy: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "UserId", "out">>;
+    updatedBy: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "UserId", "out">>;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export type Row = z.infer<typeof Row>;
+//# sourceMappingURL=properties.d.ts.map

package/dist/contract/properties.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"properties.d.ts","sourceRoot":"","sources":["../../src/contract/properties.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;;;GAMG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;EAoBvB,CAAA;AACF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AAEvD,wDAAwD;AACxD,eAAO,MAAM,YAAY;;;;;;;;;iBAMvB,CAAA;AACF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AAEvD,oFAAoF;AACpF,eAAO,MAAM,cAAc;;;;;;;;;;;;;EAazB,CAAA;AACF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAE3D;;;;;;GAMG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmBzB,CAAA;AACF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAE3D,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBASnB,CAAA;AACF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA;AAE/C;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,cAAc,CAAA;AAExC,eAAO,MAAM,QAAQ;;;;;;;EAAwE,CAAA;AAC7F,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA;AAE/C,kFAAkF;AAClF,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;EAezB,CAAA;AACF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAE3D,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;iBAIjB,CAAA;AAEF,eAAO,MAAM,IAAI;;;;;;iBAGf,CAAA;AAEF,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAarB,CAAA;AACF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAA;AAEnD,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAQf,CAAA;AACF,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAA;AAEvC,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAYnB,CAAA;AACF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA;AAE/C,kFAAkF;AAClF,eAAO,MAAM,GAAG;;;;;;;;;;;iBAWd,CAAA;AACF,MAAM,MAAM,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,GAAG,CAAC,CAAA"}

package/dist/contract/properties.js

@@ -0,0 +1,175 @@
+import { Id, Timestamp, UserId } from '@kernhq/contracts';
+import { z } from 'zod';
+/**
+ * What a column can be.
+ *
+ * The set is closed on purpose. A property type is not just a input widget: it decides how a value
+ * sorts, what a filter can ask of it, and whether a rollup can add it up. An open set would mean a
+ * table view that can display something no filter can find.
+ */
+export const PropertyType = z.enum([
+    'text',
+    'number',
+    'select',
+    'multi_select',
+    'status',
+    'date',
+    'person',
+    'files',
+    'checkbox',
+    'url',
+    'email',
+    'phone',
+    'relation',
+    'rollup',
+    'formula',
+    'created_time',
+    'created_by',
+    'edited_time',
+    'edited_by',
+]);
+/** A choice in a select, a multi-select or a status. */
+export const SelectOption = z.object({
+    id: z.string().min(1).max(64),
+    label: z.string().min(1).max(120),
+    colour: z.string().max(32).default('slate'),
+    /** status only: which band of the workflow this sits in */
+    group: z.enum(['todo', 'doing', 'done']).optional(),
+});
+/** How a rollup reduces the values it gathers from the other side of a relation. */
+export const RollupFunction = z.enum([
+    'count',
+    'count_values',
+    'count_unique',
+    'sum',
+    'average',
+    'min',
+    'max',
+    'range',
+    'show_original',
+    'checked',
+    'unchecked',
+    'percent_checked',
+]);
+/**
+ * Everything a type needs beyond its name.
+ *
+ * One permissive object rather than a discriminated union per type: the union would have to be
+ * exhaustive at every boundary, and a column's configuration is read by code that already knows
+ * which type it is holding. What matters is that adding a type never needs a migration.
+ */
+export const PropertyConfig = z.object({
+    options: z.array(SelectOption).optional(),
+    /** number: how it is drawn — plain, a percentage, a currency, a bar */
+    format: z.string().max(32).optional(),
+    precision: z.number().int().min(0).max(8).optional(),
+    /** date: whether the value carries a time, and whether it is a range */
+    includeTime: z.boolean().optional(),
+    isRange: z.boolean().optional(),
+    /** relation: the database on the other side, and the property that points back */
+    relationDatabaseId: Id.optional(),
+    relationPropertyId: Id.optional(),
+    /** rollup: which relation to walk, which property to gather, and how to reduce it */
+    rollupRelationPropertyId: Id.optional(),
+    rollupTargetPropertyId: Id.optional(),
+    rollupFunction: RollupFunction.optional(),
+    /** formula: the expression, exactly as somebody typed it */
+    expression: z.string().max(4000).optional(),
+    /** person: whether more than one may be chosen */
+    multiple: z.boolean().optional(),
+});
+export const Property = z.object({
+    id: Id,
+    databaseId: Id,
+    key: z.string().min(1).max(64),
+    name: z.string().min(1).max(120),
+    type: PropertyType,
+    config: PropertyConfig,
+    position: z.string(),
+    hidden: z.boolean(),
+});
+/**
+ * A cell.
+ *
+ * Deliberately loose: the shape depends on the column's type, and the server validates a value
+ * against its own property before it is written. Typing it here as a union would put the same
+ * exhaustive switch in every consumer that only ever renders one type at a time.
+ */
+export const PropertyValue = z.unknown();
+export const ViewKind = z.enum(['table', 'board', 'calendar', 'gallery', 'list', 'timeline']);
+/** How a filter compares. Which of these a column accepts depends on its type. */
+export const FilterOperator = z.enum([
+    'equals',
+    'not_equals',
+    'contains',
+    'not_contains',
+    'starts_with',
+    'ends_with',
+    'is_empty',
+    'is_not_empty',
+    'greater_than',
+    'less_than',
+    'on_or_before',
+    'on_or_after',
+    'is_any_of',
+    'is_none_of',
+]);
+export const Filter = z.object({
+    propertyKey: z.string(),
+    operator: FilterOperator,
+    value: z.unknown().optional(),
+});
+export const Sort = z.object({
+    propertyKey: z.string(),
+    direction: z.enum(['asc', 'desc']).default('asc'),
+});
+export const ViewConfig = z.object({
+    filters: z.array(Filter).default([]),
+    /** every filter must hold, or any one of them */
+    filterMode: z.enum(['and', 'or']).default('and'),
+    sorts: z.array(Sort).default([]),
+    /** board: which property makes the columns; calendar: which date is plotted */
+    groupBy: z.string().nullable().default(null),
+    dateProperty: z.string().nullable().default(null),
+    visibleProperties: z.array(z.string()).nullable().default(null),
+    columnWidths: z.record(z.string(), z.number()).default({}),
+    cardSize: z.enum(['small', 'medium', 'large']).default('medium'),
+    /** gallery: which files property provides the picture */
+    coverProperty: z.string().nullable().default(null),
+});
+export const View = z.object({
+    id: Id,
+    databaseId: Id,
+    name: z.string().min(1).max(120),
+    kind: ViewKind,
+    config: ViewConfig,
+    position: z.string(),
+    isDefault: z.boolean(),
+});
+export const Database = z.object({
+    id: Id,
+    workspaceId: z.string(),
+    spaceId: Id,
+    pageId: Id,
+    name: z.string(),
+    description: z.string(),
+    inline: z.boolean(),
+    properties: z.array(Property),
+    views: z.array(View),
+    createdAt: Timestamp,
+    updatedAt: Timestamp,
+});
+/** A row: the page, plus its cells and whatever the server computed from them. */
+export const Row = z.object({
+    id: Id,
+    databaseId: Id,
+    title: z.string(),
+    icon: z.string().nullable(),
+    props: z.record(z.string(), PropertyValue),
+    computed: z.record(z.string(), PropertyValue),
+    createdBy: UserId.nullable(),
+    updatedBy: UserId.nullable(),
+    createdAt: Timestamp,
+    updatedAt: Timestamp,
+});
+//# sourceMappingURL=properties.js.map