@lix-js/sdk 0.4.6 → 0.5.0-preview.0

package/dist/schema-definition/definition.d.ts

@@ -0,0 +1,406 @@
+import type { FromSchema, JSONSchema } from "json-schema-to-ts";
+export declare const LixSchemaDefinition: {
+    readonly $schema: "http://json-schema.org/draft-07/schema#";
+    readonly title: "Lix Change Schema";
+    readonly description: "A JSON schema document that also includes custom x-key and x-version properties for identification and versioning.";
+    readonly allOf: readonly [{
+        readonly $ref: "http://json-schema.org/draft-07/schema#";
+    }, {
+        readonly type: "object";
+        readonly properties: {
+            readonly "x-lix-unique": {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+            };
+            readonly "x-primary-key": {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+            };
+            readonly "x-lix-foreign-keys": {
+                readonly type: "object";
+                readonly additionalProperties: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly schemaKey: {
+                            readonly type: "string";
+                            readonly description: "The x-lix-key of the referenced schema";
+                        };
+                        readonly property: {
+                            readonly type: "string";
+                            readonly description: "The property name in the referenced schema";
+                        };
+                        readonly schemaVersion: {
+                            readonly type: "string";
+                            readonly pattern: "^\\d+\\.\\d+$";
+                            readonly description: "Optional version of the referenced schema";
+                        };
+                    };
+                    readonly required: readonly ["schemaKey", "property"];
+                };
+            };
+            readonly "x-lix-key": {
+                readonly type: "string";
+                readonly description: "The key of the schema. The key is used to identify the schema. You must use a unique key for each schema.";
+                readonly examples: readonly ["csv_plugin_cell"];
+            };
+            readonly "x-lix-version": {
+                readonly type: "string";
+                readonly description: "The version of the schema. Use the major version to signal breaking changes. Use the minor version to signal non-breaking changes.";
+                readonly pattern: "^\\d+\\.\\d+$";
+                readonly examples: readonly ["1.0"];
+            };
+            readonly properties: {
+                readonly type: "object";
+                readonly additionalProperties: {
+                    readonly allOf: readonly [{
+                        readonly $ref: "http://json-schema.org/draft-07/schema#";
+                    }, {
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly "x-lix-generated": {
+                                readonly type: "boolean";
+                                readonly description: "Whether this property is auto-generated by the database";
+                            };
+                        };
+                    }];
+                };
+            };
+        };
+        readonly required: readonly ["x-lix-key", "x-lix-version"];
+    }];
+};
+/**
+ * Extended property schema that includes Lix-specific extensions
+ */
+type LixPropertySchema = JSONSchema & {
+    "x-lix-generated"?: boolean;
+};
+/**
+ * LixSchema
+ *
+ * A superset of JSON Schema (draft-07) that includes Lix-specific metadata
+ * and supports custom extensions.
+ *
+ * Custom extensions may be added with any x-* prefix.
+ */
+export type LixSchemaDefinition = JSONSchema & {
+    /**
+     * The key of the schema.
+     *
+     * The key is used to identify the schema. You must use a
+     * unique key for each schema.
+     *
+     * @example
+     *   "csv_plugin_cell"
+     */
+    "x-lix-key": string;
+    /**
+     * The version of the schema.
+     *
+     * Use the major version to signal breaking changes.
+     * Use the minor version to signal non-breaking changes.
+     *
+     * @example
+     *   "1.0"
+     */
+    "x-lix-version": string;
+    "x-lix-primary-key"?: string[] | readonly string[];
+    /**
+     * Properties that must be unique per version.
+     *
+     * Not to be confused by `x-version` which is used for versioning the schema.
+     *
+     *
+     * @example
+     *   {
+     *     "x-lix-unique": [
+     *       // the id must be unique
+     *       ["id"],
+     *       // the name and age must be unique as well
+     *       ["name", "age"],
+     *     ],
+     *     properties: {
+     *       id: { type: "string" },
+     *       name: { type: "string" },
+     *       age: { type: "number" },
+     *     },
+     *   }
+     */
+    "x-lix-unique"?: string[][] | readonly (readonly string[])[];
+    /**
+     * Foreign key constraints referencing other schemas.
+     *
+     * @example
+     *   {
+     *     "x-lix-foreign-keys": {
+     *       "author_id": {
+     *         "schemaKey": "user_profile",
+     *         "property": "id"
+     *       },
+     *       "category_id": {
+     *         "schemaKey": "post_category",
+     *         "property": "id"
+     *       }
+     *     }
+     *   }
+     */
+    "x-lix-foreign-keys"?: {
+        [localProperty: string]: {
+            schemaKey: string;
+            property: string;
+            schemaVersion?: string;
+        };
+    };
+    type: "object";
+    properties?: {
+        [key: string]: LixPropertySchema;
+    };
+};
+/**
+ * Marker type for database columns that are auto-generated.
+ *
+ * This type brands values as "generated" to enable special handling in insert/update
+ * operations. Generated fields become optional in inserts since the database
+ * provides default values.
+ *
+ * The type accepts T values directly for developer convenience while preserving
+ * the generated marker for type transformations.
+ *
+ * @example
+ * ```typescript
+ * type Account = {
+ *   id: LixGenerated<string>;  // Auto-generated UUID
+ *   name: string;              // User-provided
+ *   created_at: LixGenerated<string>;  // Auto-generated timestamp
+ * };
+ *
+ * // In inserts, generated fields are optional
+ * const newAccount: LixInsertable<Account> = {
+ *   name: "John"  // id and created_at are optional
+ * };
+ * ```
+ */
+export type LixGenerated<T> = T & {
+    readonly __lixGenerated?: true;
+};
+/**
+ * Check if a type has the LixGenerated brand
+ */
+type IsLixGenerated<T> = T extends {
+    readonly __lixGenerated?: true;
+} ? true : false;
+/**
+ * Extract the base type from LixGenerated<T>
+ * Since LixGenerated<T> = T & { brand }, we need to extract T
+ */
+type ExtractFromGenerated<T> = T extends LixGenerated<infer U> ? U : T;
+/**
+ * Extract the select type from LixGenerated or return the type as-is
+ */
+type SelectType<T> = ExtractFromGenerated<T>;
+/**
+ * Extract the insert type from LixGenerated or return the type as-is
+ */
+type InsertType<T> = IsLixGenerated<T> extends true ? ExtractFromGenerated<T> | undefined : T;
+/**
+ * Extract the update type from LixGenerated or return the type as-is
+ */
+type UpdateType<T> = ExtractFromGenerated<T>;
+/**
+ * Evaluates to K if T can be null or undefined
+ */
+type IfNullable<T, K> = undefined extends T ? K : null extends T ? K : never;
+/**
+ * Evaluates to K if T can't be null or undefined
+ */
+type IfNotNullable<T, K> = undefined extends T ? never : null extends T ? never : T extends never ? never : K;
+/**
+ * Keys whose InsertType can be null or undefined (optional in inserts)
+ */
+type NullableInsertKeys<T> = {
+    [K in keyof T]: IfNullable<InsertType<T[K]>, K>;
+}[keyof T];
+/**
+ * Keys whose InsertType can't be null or undefined (required in inserts)
+ */
+type NonNullableInsertKeys<T> = {
+    [K in keyof T]: IfNotNullable<InsertType<T[K]>, K>;
+}[keyof T];
+/**
+ * Transform a type for insert operations.
+ *
+ * This type makes LixGenerated fields optional while keeping other required
+ * fields mandatory. Use this when defining types for creating new entities.
+ *
+ * The database will automatically populate generated fields (like IDs,
+ * timestamps) if not provided.
+ *
+ * @example
+ * ```typescript
+ * type Account = {
+ *   id: LixGenerated<string>;
+ *   name: string;
+ *   email: string;
+ *   created_at: LixGenerated<string>;
+ * };
+ *
+ * type NewAccount = LixInsertable<Account>;
+ * // Result: { name: string; email: string; id?: string; created_at?: string; }
+ *
+ * const account: NewAccount = {
+ *   name: "John",
+ *   email: "john@example.com"
+ *   // id and created_at are optional
+ * };
+ * ```
+ */
+export type LixInsertable<T> = {
+    [K in NonNullableInsertKeys<T>]: InsertType<T[K]>;
+} & {
+    [K in NullableInsertKeys<T>]?: InsertType<T[K]>;
+};
+/**
+ * Transform a type for update operations.
+ *
+ * This type makes all fields optional, allowing partial updates where you
+ * only specify the fields you want to change. LixGenerated markers are
+ * removed since you're providing explicit values.
+ *
+ * The database preserves existing values for any fields not included
+ * in the update.
+ *
+ * @example
+ * ```typescript
+ * type Account = {
+ *   id: LixGenerated<string>;
+ *   name: string;
+ *   email: string;
+ *   updated_at: LixGenerated<string>;
+ * };
+ *
+ * type AccountUpdate = LixUpdateable<Account>;
+ * // Result: { id?: string; name?: string; email?: string; updated_at?: string; }
+ *
+ * // Update only the email
+ * const updates: AccountUpdate = {
+ *   email: "newemail@example.com"
+ *   // Other fields remain unchanged
+ * };
+ * ```
+ */
+export type LixUpdateable<T> = {
+    [K in keyof T]?: UpdateType<T[K]>;
+};
+/**
+ * Transform a type for select/query operations.
+ *
+ * This type unwraps all LixGenerated markers, giving you the actual runtime
+ * types that will be returned from database queries. All fields are required
+ * and have their base types.
+ *
+ * Use this type when defining the shape of data returned from queries or
+ * when passing entity data to UI components.
+ *
+ * @example
+ * ```typescript
+ * type Account = {
+ *   id: LixGenerated<string>;
+ *   name: string;
+ *   email: string;
+ *   created_at: LixGenerated<string>;
+ * };
+ *
+ * type AccountData = LixSelectable<Account>;
+ * // Result: { id: string; name: string; email: string; created_at: string; }
+ *
+ * // Query results have this shape
+ * const accounts: AccountData[] = await db
+ *   .selectFrom("account")
+ *   .selectAll()
+ *   .execute();
+ *
+ * console.log(accounts[0].id);  // string (not LixGenerated<string>)
+ * ```
+ */
+export type LixSelectable<T> = {
+    [K in keyof T]: SelectType<T[K]>;
+};
+/**
+ * Transform object types with no properties from unknown to Record<string, any>
+ */
+type TransformEmptyObject<T> = T extends {
+    [x: string]: unknown;
+} ? Record<string, any> : T;
+/**
+ * Check if a schema property is an empty object type (no properties defined)
+ */
+type IsEmptyObjectSchema<P> = P extends {
+    type: "object";
+} ? P extends {
+    properties: any;
+} ? false : true : false;
+/**
+ * Get the nullable part of a type based on schema
+ */
+type GetNullablePart<P> = P extends {
+    nullable: true;
+} ? null : never;
+/**
+ * Internal type that applies LixGenerated markers to properties with x-lix-generated: true
+ */
+type ApplyLixGenerated<TSchema extends LixSchemaDefinition> = TSchema extends {
+    properties: infer Props;
+} ? {
+    [K in keyof FromSchema<TSchema>]: K extends keyof Props ? Props[K] extends {
+        "x-lix-generated": true;
+    } ? LixGenerated<TransformEmptyObject<FromSchema<TSchema>[K]>> : IsEmptyObjectSchema<Props[K]> extends true ? Record<string, any> | GetNullablePart<Props[K]> : TransformEmptyObject<FromSchema<TSchema>[K]> : TransformEmptyObject<FromSchema<TSchema>[K]>;
+} : never;
+/**
+ * Convert a LixSchemaDefinition to a TypeScript type.
+ *
+ * This type transformation:
+ * 1. Converts JSON Schema properties to TypeScript types
+ * 2. Wraps properties with `x-lix-generated: true` in LixGenerated markers
+ * 3. Transforms `type: "object"` without properties to `Record<string, any>`
+ *
+ * The resulting type can be used with LixInsertable, LixUpdateable, and
+ * LixSelectable for database operations.
+ *
+ * @example
+ * ```typescript
+ * const AccountSchema = {
+ *   "x-lix-key": "account",
+ *   "x-lix-version": "1.0",
+ *   "x-lix-primary-key": ["id"],
+ *   type: "object",
+ *   properties: {
+ *     id: { type: "string", "x-lix-generated": true },
+ *     name: { type: "string" },
+ *     email: { type: "string" },
+ *     metadata: { type: "object" },  // Becomes Record<string, any>
+ *     created_at: { type: "string", "x-lix-generated": true }
+ *   },
+ *   required: ["id", "name", "email"],
+ *   additionalProperties: false
+ * } as const satisfies LixSchemaDefinition;
+ *
+ * type Account = FromLixSchemaDefinition<typeof AccountSchema>;
+ * // Result: {
+ * //   id: LixGenerated<string>;
+ * //   name: string;
+ * //   email: string;
+ * //   metadata: Record<string, any> | undefined;
+ * //   created_at: LixGenerated<string> | undefined;
+ * // }
+ * ```
+ */
+export type FromLixSchemaDefinition<T extends LixSchemaDefinition> = ApplyLixGenerated<T>;
+export {};
+//# sourceMappingURL=definition.d.ts.map

package/dist/schema-definition/definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/schema-definition/definition.ts"],"names":[],"mappings":"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"}

package/dist/schema-definition/definition.js

@@ -0,0 +1,82 @@
+export const LixSchemaDefinition = {
+    $schema: "http://json-schema.org/draft-07/schema#",
+    title: "Lix Change Schema",
+    description: "A JSON schema document that also includes custom x-key and x-version properties for identification and versioning.",
+    allOf: [
+        {
+            $ref: "http://json-schema.org/draft-07/schema#",
+        },
+        {
+            type: "object",
+            properties: {
+                "x-lix-unique": {
+                    type: "array",
+                    items: {
+                        type: "array",
+                        items: {
+                            type: "string",
+                        },
+                    },
+                },
+                "x-primary-key": {
+                    type: "array",
+                    items: {
+                        type: "string",
+                    },
+                },
+                "x-lix-foreign-keys": {
+                    type: "object",
+                    additionalProperties: {
+                        type: "object",
+                        properties: {
+                            schemaKey: {
+                                type: "string",
+                                description: "The x-lix-key of the referenced schema",
+                            },
+                            property: {
+                                type: "string",
+                                description: "The property name in the referenced schema",
+                            },
+                            schemaVersion: {
+                                type: "string",
+                                pattern: "^\\d+\\.\\d+$",
+                                description: "Optional version of the referenced schema",
+                            },
+                        },
+                        required: ["schemaKey", "property"],
+                    },
+                },
+                "x-lix-key": {
+                    type: "string",
+                    description: "The key of the schema. The key is used to identify the schema. You must use a unique key for each schema.",
+                    examples: ["csv_plugin_cell"],
+                },
+                "x-lix-version": {
+                    type: "string",
+                    description: "The version of the schema. Use the major version to signal breaking changes. Use the minor version to signal non-breaking changes.",
+                    pattern: "^\\d+\\.\\d+$",
+                    examples: ["1.0"],
+                },
+                properties: {
+                    type: "object",
+                    additionalProperties: {
+                        allOf: [
+                            { $ref: "http://json-schema.org/draft-07/schema#" },
+                            {
+                                type: "object",
+                                properties: {
+                                    "x-lix-generated": {
+                                        type: "boolean",
+                                        description: "Whether this property is auto-generated by the database",
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                },
+            },
+            required: ["x-lix-key", "x-lix-version"],
+        },
+    ],
+};
+//# sourceMappingURL=definition.js.map

package/dist/schema-definition/definition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.js","sourceRoot":"","sources":["../../src/schema-definition/definition.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,mBAAmB,GAAG;IAClC,OAAO,EAAE,yCAAyC;IAClD,KAAK,EAAE,mBAAmB;IAC1B,WAAW,EACV,oHAAoH;IACrH,KAAK,EAAE;QACN;YACC,IAAI,EAAE,yCAAyC;SAC/C;QACD;YACC,IAAI,EAAE,QAAQ;YACd,UAAU,EAAE;gBACX,cAAc,EAAE;oBACf,IAAI,EAAE,OAAO;oBACb,KAAK,EAAE;wBACN,IAAI,EAAE,OAAO;wBACb,KAAK,EAAE;4BACN,IAAI,EAAE,QAAQ;yBACd;qBACD;iBACD;gBACD,eAAe,EAAE;oBAChB,IAAI,EAAE,OAAO;oBACb,KAAK,EAAE;wBACN,IAAI,EAAE,QAAQ;qBACd;iBACD;gBACD,oBAAoB,EAAE;oBACrB,IAAI,EAAE,QAAQ;oBACd,oBAAoB,EAAE;wBACrB,IAAI,EAAE,QAAQ;wBACd,UAAU,EAAE;4BACX,SAAS,EAAE;gCACV,IAAI,EAAE,QAAQ;gCACd,WAAW,EAAE,wCAAwC;6BACrD;4BACD,QAAQ,EAAE;gCACT,IAAI,EAAE,QAAQ;gCACd,WAAW,EAAE,4CAA4C;6BACzD;4BACD,aAAa,EAAE;gCACd,IAAI,EAAE,QAAQ;gCACd,OAAO,EAAE,eAAe;gCACxB,WAAW,EAAE,2CAA2C;6BACxD;yBACD;wBACD,QAAQ,EAAE,CAAC,WAAW,EAAE,UAAU,CAAC;qBACnC;iBACD;gBACD,WAAW,EAAE;oBACZ,IAAI,EAAE,QAAQ;oBACd,WAAW,EACV,2GAA2G;oBAC5G,QAAQ,EAAE,CAAC,iBAAiB,CAAC;iBAC7B;gBACD,eAAe,EAAE;oBAChB,IAAI,EAAE,QAAQ;oBACd,WAAW,EACV,oIAAoI;oBACrI,OAAO,EAAE,eAAe;oBACxB,QAAQ,EAAE,CAAC,KAAK,CAAC;iBACjB;gBACD,UAAU,EAAE;oBACX,IAAI,EAAE,QAAQ;oBACd,oBAAoB,EAAE;wBACrB,KAAK,EAAE;4BACN,EAAE,IAAI,EAAE,yCAAyC,EAAE;4BACnD;gCACC,IAAI,EAAE,QAAQ;gCACd,UAAU,EAAE;oCACX,iBAAiB,EAAE;wCAClB,IAAI,EAAE,SAAS;wCACf,WAAW,EACV,yDAAyD;qCAC1D;iCACD;6BACD;yBACD;qBACD;iBACD;aACD;YACD,QAAQ,EAAE,CAAC,WAAW,EAAE,eAAe,CAAC;SACxC;KACD;CACQ,CAAC"}

package/dist/schema-definition/definition.test-d.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=definition.test-d.d.ts.map

package/dist/schema-definition/definition.test-d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.test-d.d.ts","sourceRoot":"","sources":["../../src/schema-definition/definition.test-d.ts"],"names":[],"mappings":""}

package/dist/schema-definition/definition.test-d.js

@@ -0,0 +1,177 @@
+import { test, assertType } from "vitest";
+test("a json change schema should be infer the properties", () => {
+    const jsonChangeSchema = {
+        "x-lix-version": "1.0",
+        "x-lix-key": "mock",
+        type: "object",
+        properties: {
+            name: { type: "string" },
+            age: { type: "number" },
+            location: { type: "object" },
+        },
+        required: ["name", "age", "location"],
+        additionalProperties: false,
+    };
+    const snapshot = {
+        name: "John",
+        age: 5,
+        location: {
+            city: "New York",
+            country: "USA",
+        },
+    };
+    assertType(snapshot);
+});
+test("LixInsertable combined with LixGenerated makes columns optional", () => {
+    // pass (all properties are provided)
+    const z = {
+        id: "123",
+        name: "Test",
+    };
+    // pass (LixGenerated makes id optional)
+    const a = {
+        name: "Test",
+    };
+    // @ts-expect-error - Name is required in MockType
+    const x = {};
+    // @ts-expect-error - Name is required in MockType
+    const y = {
+        id: "123",
+    };
+});
+test("LixSelectable unwraps LixGenerated fields to their base types", () => {
+    // All fields should be present and LixGenerated should be unwrapped
+    const selected = {
+        id: "123",
+        name: "Test",
+        count: 42,
+        metadata: { foo: "bar" },
+    };
+    // Type checking - all fields are required
+    // @ts-expect-error - All fields are required in selectable
+    const missing1 = {
+        id: "123",
+        name: "Test",
+        count: 42,
+        // missing metadata
+    };
+    // @ts-expect-error - All fields are required in selectable
+    const missing2 = {
+        // missing id
+        name: "Test",
+        count: 42,
+        metadata: { foo: "bar" },
+    };
+    // @ts-expect-error - All fields are required in selectable
+    const missing3 = {
+        id: "123",
+        // missing name
+        count: 42,
+        metadata: { foo: "bar" },
+    };
+    const idValue = "test";
+    const countValue = 123;
+});
+test("LixUpdateable makes all fields optional and unwraps LixGenerated", () => {
+    // All fields should be optional in updates
+    const update1 = {}; // Empty object is valid
+    const update2 = {
+        id: "new-id",
+    };
+    const update3 = {
+        name: "Updated Name",
+    };
+    const update4 = {
+        count: 100,
+    };
+    const update5 = {
+        metadata: { foo: "updated" },
+    };
+    const update6 = {
+        optional: "now set",
+    };
+    // Can update multiple fields at once
+    const update7 = {
+        id: "new-id",
+        name: "New Name",
+        count: 99,
+        metadata: { foo: "baz" },
+        optional: "value",
+    };
+    // These should all work since fields are optional
+    const idUpdate = undefined;
+    const countUpdate = undefined;
+    const nameUpdate = undefined;
+    // But when provided, must be correct type
+    const wrongType1 = {
+        // @ts-expect-error - id must be string when provided
+        id: 123,
+    };
+    const wrongType2 = {
+        // @ts-expect-error - count must be number when provided
+        count: "not a number",
+    };
+    const wrongType3 = {
+        // @ts-expect-error - metadata must match structure when provided
+        metadata: { bar: "wrong key" },
+    };
+});
+test("FromLixSchemaDefinition transforms schema with x-lix-generated to LixGenerated types", () => {
+    // Define a test schema with x-lix-generated properties
+    const TestSchema = {
+        "x-lix-key": "test_entity",
+        "x-lix-version": "1.0",
+        "x-lix-primary-key": ["id"],
+        type: "object",
+        properties: {
+            id: {
+                type: "string",
+                "x-lix-generated": true,
+            },
+            name: {
+                type: "string",
+            },
+        },
+        required: ["id", "name"],
+        additionalProperties: false,
+    };
+    // Test with LixInsertable - generated fields should be optional
+    const insertable = {
+        // id is optional
+        name: "test",
+    };
+    // Can also provide generated fields
+    const insertableWithGenerated = {
+        id: "custom-id",
+        name: "test",
+    };
+});
+test("FromLixSchemaDefinition transforms empty object types to Record<string, any>", () => {
+    const TestSchema = {
+        "x-lix-key": "test_entity",
+        "x-lix-version": "1.0",
+        "x-lix-primary-key": ["id"],
+        type: "object",
+        properties: {
+            id: { type: "string" },
+            metadata: { type: "object" },
+            config: { type: "object", nullable: true },
+        },
+        required: ["id", "metadata"],
+        additionalProperties: false,
+    };
+    // Test that metadata is Record<string, any>
+    const entity = {
+        id: "test",
+        metadata: {
+            author: "test-user",
+            created_at: new Date().toISOString(),
+            nested: { deep: { value: 123 } },
+        },
+        config: null,
+    };
+    // Verify types
+    assertType(entity.metadata);
+    assertType(entity.config);
+});
+//# sourceMappingURL=definition.test-d.js.map