@lix-js/sdk 0.4.7 → 0.5.0-preview.1

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

@@ -0,0 +1,449 @@
+import type { FromSchema, JSONSchema } from "json-schema-to-ts";
+/**
+ * Foreign key constraint definition
+ */
+export type LixForeignKey = {
+    /**
+     * Local JSON-schema property names that participate in the FK.
+     * Must have at least one property.
+     */
+    properties: readonly string[] | string[];
+    /**
+     * Where they point to.
+     */
+    references: {
+        /**
+         * The x-lix-key of the referenced schema
+         */
+        schemaKey: string;
+        /**
+         * Remote property names (must have same length as local properties)
+         */
+        properties: readonly string[] | string[];
+        /**
+         * Optional version of the referenced schema
+         */
+        schemaVersion?: string;
+    };
+};
+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: "array";
+                readonly items: {
+                    readonly type: "object";
+                    readonly required: readonly ["properties", "references"];
+                    readonly properties: {
+                        readonly properties: {
+                            readonly type: "array";
+                            readonly minItems: 1;
+                            readonly items: {
+                                readonly type: "string";
+                            };
+                            readonly description: "Local JSON-schema property names that participate in the FK";
+                        };
+                        readonly references: {
+                            readonly type: "object";
+                            readonly required: readonly ["schemaKey", "properties"];
+                            readonly properties: {
+                                readonly schemaKey: {
+                                    readonly type: "string";
+                                    readonly description: "The x-lix-key of the referenced schema";
+                                };
+                                readonly properties: {
+                                    readonly type: "array";
+                                    readonly minItems: 1;
+                                    readonly items: {
+                                        readonly type: "string";
+                                    };
+                                    readonly description: "Remote property names (same length as local properties)";
+                                };
+                                readonly schemaVersion: {
+                                    readonly type: "string";
+                                    readonly pattern: "^\\d+\\.\\d+$";
+                                    readonly description: "Optional version of the referenced schema";
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+            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
+     *   [
+     *     {
+     *       "properties": ["author_id"],
+     *       "references": {
+     *         "schemaKey": "user_profile",
+     *         "properties": ["id"]
+     *       }
+     *     },
+     *     {
+     *       "properties": ["entity_id", "schema_key", "file_id"],
+     *       "references": {
+     *         "schemaKey": "state",
+     *         "properties": ["entity_id", "schema_key", "file_id"]
+     *       }
+     *     }
+     *   ]
+     */
+    "x-lix-foreign-keys"?: LixForeignKey[] | readonly LixForeignKey[];
+    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,106 @@
+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: "array",
+                    items: {
+                        type: "object",
+                        required: ["properties", "references"],
+                        properties: {
+                            properties: {
+                                type: "array",
+                                minItems: 1,
+                                items: { type: "string" },
+                                description: "Local JSON-schema property names that participate in the FK",
+                            },
+                            references: {
+                                type: "object",
+                                required: ["schemaKey", "properties"],
+                                properties: {
+                                    schemaKey: {
+                                        type: "string",
+                                        description: "The x-lix-key of the referenced schema",
+                                    },
+                                    properties: {
+                                        type: "array",
+                                        minItems: 1,
+                                        items: { type: "string" },
+                                        description: "Remote property names (same length as local properties)",
+                                    },
+                                    schemaVersion: {
+                                        type: "string",
+                                        pattern: "^\\d+\\.\\d+$",
+                                        description: "Optional version of the referenced schema",
+                                    },
+                                },
+                            },
+                            // onDelete: {
+                            //   type: "string",
+                            //   enum: ["cascade", "restrict", "set null"],
+                            //   description: "Action to take when referenced entity is deleted (future feature)"
+                            // },
+                            // onUpdate: {
+                            //   type: "string",
+                            //   enum: ["cascade", "restrict"],
+                            //   description: "Action to take when referenced entity is updated (future feature)"
+                            // },
+                        },
+                    },
+                },
+                "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":"AAmCA,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,OAAO;oBACb,KAAK,EAAE;wBACN,IAAI,EAAE,QAAQ;wBACd,QAAQ,EAAE,CAAC,YAAY,EAAE,YAAY,CAAC;wBACtC,UAAU,EAAE;4BACX,UAAU,EAAE;gCACX,IAAI,EAAE,OAAO;gCACb,QAAQ,EAAE,CAAC;gCACX,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;gCACzB,WAAW,EACV,6DAA6D;6BAC9D;4BACD,UAAU,EAAE;gCACX,IAAI,EAAE,QAAQ;gCACd,QAAQ,EAAE,CAAC,WAAW,EAAE,YAAY,CAAC;gCACrC,UAAU,EAAE;oCACX,SAAS,EAAE;wCACV,IAAI,EAAE,QAAQ;wCACd,WAAW,EAAE,wCAAwC;qCACrD;oCACD,UAAU,EAAE;wCACX,IAAI,EAAE,OAAO;wCACb,QAAQ,EAAE,CAAC;wCACX,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;wCACzB,WAAW,EACV,yDAAyD;qCAC1D;oCACD,aAAa,EAAE;wCACd,IAAI,EAAE,QAAQ;wCACd,OAAO,EAAE,eAAe;wCACxB,WAAW,EAAE,2CAA2C;qCACxD;iCACD;6BACD;4BACD,cAAc;4BACd,oBAAoB;4BACpB,+CAA+C;4BAC/C,qFAAqF;4BACrF,KAAK;4BACL,cAAc;4BACd,oBAAoB;4BACpB,mCAAmC;4BACnC,qFAAqF;4BACrF,KAAK;yBACL;qBACD;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":""}