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

package/dist/entity-views/generic-types.test.js

@@ -0,0 +1,99 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { test } from "vitest";
+test("ToKysely converts LixGenerated to Kysely Generated", () => {
+    // Verify the conversion is correct by creating a type-compatible object
+    const kyselyTable = {
+        id: {},
+        name: "test",
+        count: {},
+        metadata: { foo: "bar" },
+        optional: null,
+    };
+    // These should work
+    const id = {};
+    const name = "test";
+    const count = {};
+    const metadata = { foo: "test" };
+    const optional1 = "value";
+    const optional2 = null;
+    const optional3 = undefined;
+    // TODO: Test with nested LixGenerated when ToKysely supports deep transformation
+    // Currently ToKysely only transforms top-level properties
+});
+test("Composing entity types with StateEntityColumns and using ToKysely", () => {
+    // Test LixInsertable with composed type
+    const insertable = {
+        key: "test-key",
+        value: { foo: "bar" },
+        // lixcol fields are optional in inserts
+    };
+    // Can also provide lixcol fields if needed
+    const insertableWithLixcol = {
+        key: "test-key",
+        value: 123,
+        lixcol_file_id: "custom-file",
+        lixcol_created_at: "2024-01-01",
+    };
+    // Test LixSelectable with composed type - all fields required and unwrapped
+    const selectable = {
+        key: "test-key",
+        value: [1, 2, 3],
+        lixcol_file_id: "lix",
+        lixcol_inherited_from_version_id: null,
+        lixcol_created_at: "2024-01-01",
+        lixcol_updated_at: "2024-01-01",
+    };
+    // This is what Kysely would expect at the database boundary
+    const kyselyView = {
+        key: "test-key",
+        value: "json-string",
+        lixcol_file_id: {},
+        lixcol_inherited_from_version_id: {},
+        lixcol_created_at: {},
+        lixcol_updated_at: {},
+    };
+    const fileId = {};
+    const inherited = {};
+});
+test("Business logic types with LixGenerated markers work with NewState", () => {
+    // Define a mock schema with x-lix-generated
+    const MockEntitySchema = {
+        "x-lix-key": "mock_entity",
+        "x-lix-version": "1.0",
+        "x-lix-primary-key": ["id"],
+        type: "object",
+        properties: {
+            id: { type: "string", "x-lix-generated": true },
+            name: { type: "string" },
+            count: { type: "number", "x-lix-generated": true },
+            optional_field: { type: "string", nullable: true },
+        },
+        required: ["id", "name", "count"],
+        additionalProperties: false,
+    };
+    // Test that NewState makes generated fields optional
+    const newMockEntity = {
+        name: "test-name",
+        // id should be optional because it's LixGenerated
+        // count should be optional because it's LixGenerated
+        // optional_field should be optional because it's nullable
+    };
+    // Test that NewState also accepts generated fields when provided
+    const newMockEntityWithGenerated = {
+        id: "custom-id",
+        name: "test-name",
+        count: 42,
+        optional_field: "optional",
+    };
+    // Test that required non-generated fields are still required
+    // @ts-expect-error - name is required
+    const invalidNewMockEntity = {
+        count: 42,
+        // Missing required field 'name'
+    };
+    // Verify the types work as expected
+    void newMockEntity;
+    void newMockEntityWithGenerated;
+    void invalidNewMockEntity;
+});
+//# sourceMappingURL=generic-types.test.js.map

package/dist/entity-views/generic-types.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generic-types.test.js","sourceRoot":"","sources":["../../src/entity-views/generic-types.test.ts"],"names":[],"mappings":"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"}

package/dist/entity-views/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/entity-views/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/entity-views/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC"}

package/dist/entity-views/index.js

@@ -0,0 +1,2 @@
+export * from "./types.js";
+//# sourceMappingURL=index.js.map

package/dist/entity-views/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/entity-views/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC"}

package/dist/entity-views/types.d.ts

@@ -0,0 +1,309 @@
+import type { EntityStateAllColumns } from "./entity-state-all.js";
+import type { EntityStateColumns } from "./entity-state.js";
+import type { StateEntityHistoryColumns } from "./entity-state-history.js";
+import type { Generated as KyselyGenerated } from "kysely";
+import type { LixGenerated, LixInsertable, LixUpdateable, LixSelectable } from "../schema-definition/definition.js";
+/**
+ * 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>;
+/**
+ * Convert our LixGenerated types to Kysely's Generated types.
+ * This adapter is used at the database boundary.
+ */
+export type ToKysely<T> = {
+    [K in keyof T]: IsLixGenerated<T[K]> extends true ? KyselyGenerated<SelectType<T[K]>> : T[K];
+};
+/**
+ * View type for entities in the active version only.
+ *
+ * This type combines your entity properties with Lix operational columns
+ * (file_id, timestamps, etc.) while preserving LixGenerated markers for
+ * database schema compatibility.
+ *
+ * Use this type when defining database views that work with the current
+ * active version only.
+ *
+ * @example
+ * ```typescript
+ * // Define a view type for key-value entities
+ * type KeyValueView = EntityStateView<KeyValue>;
+ *
+ * // The resulting type includes both entity properties and operational columns
+ * // { key: string, value: any, lixcol_file_id: LixGenerated<string>, ... }
+ * ```
+ */
+export type EntityStateView<T> = T & EntityStateColumns;
+/**
+ * View type for entities across all versions.
+ *
+ * This type combines your entity properties with Lix operational columns
+ * including the version_id, allowing you to query and manipulate entities
+ * in specific versions.
+ *
+ * Use this type when defining database views that need to work across
+ * multiple versions.
+ *
+ * @example
+ * ```typescript
+ * // Define a view type for key-value entities across versions
+ * type KeyValueAllView = EntityStateAllView<KeyValue>;
+ *
+ * // Query entities in a specific version
+ * await lix.db
+ *   .selectFrom("key_value_all")
+ *   .where("lixcol_version_id", "=", "v2")
+ *   .selectAll()
+ *   .execute();
+ * ```
+ */
+export type EntityStateAllView<T> = T & EntityStateAllColumns;
+/**
+ * View type for entity history (read-only).
+ *
+ * This type combines your entity properties with historical tracking columns,
+ * allowing you to see how entities evolved over time through different change sets.
+ *
+ * History views are read-only and include change tracking information like
+ * change_id, change_set_id, and depth for blame functionality.
+ *
+ * @example
+ * ```typescript
+ * // Define a history view type for key-value entities
+ * type KeyValueHistoryView = EntityStateHistoryView<KeyValue>;
+ *
+ * // Query entity state at a specific change set
+ * await lix.db
+ *   .selectFrom("key_value_history")
+ *   .where("lixcol_change_set_id", "=", changeSetId)
+ *   .where("lixcol_depth", "=", 0)
+ *   .selectAll()
+ *   .execute();
+ * ```
+ */
+export type EntityStateHistoryView<T> = T & StateEntityHistoryColumns;
+/**
+ * Type for querying entities from the active version.
+ *
+ * This type unwraps all LixGenerated markers, giving you the actual runtime types
+ * for entity properties and operational columns. Use this when working with
+ * query results from the database or passing data to UI components.
+ *
+ * All properties are required and have their actual types (no LixGenerated wrappers).
+ *
+ * @example
+ * ```typescript
+ * // Use State type for UI components that display entity data
+ * interface SettingsCardProps {
+ *   setting: State<KeyValue>;
+ * }
+ *
+ * function SettingsCard({ setting }: SettingsCardProps) {
+ *   return (
+ *     <div>
+ *       <h3>{setting.key}</h3>
+ *       <p>{setting.value}</p>
+ *       <time>{setting.lixcol_updated_at}</time>
+ *     </div>
+ *   );
+ * }
+ *
+ * // Query and pass to UI
+ * const settings = await lix.db
+ *   .selectFrom("key_value")
+ *   .selectAll()
+ *   .execute();
+ *
+ * settings.map(setting => <SettingsCard setting={setting} />);
+ * ```
+ */
+export type State<T> = LixSelectable<EntityStateView<T>>;
+/**
+ * Type for querying entities across all versions.
+ *
+ * This type unwraps all LixGenerated markers and includes the version_id column,
+ * allowing you to work with entities from any version in the database.
+ *
+ * All properties are required and have their actual types (no LixGenerated wrappers).
+ *
+ * @example
+ * ```typescript
+ * // Use StateAll for version comparison UI
+ * interface VersionDiffProps {
+ *   oldValue: StateAll<KeyValue>;
+ *   newValue: StateAll<KeyValue>;
+ * }
+ *
+ * function VersionDiff({ oldValue, newValue }: VersionDiffProps) {
+ *   return (
+ *     <div>
+ *       <h4>{oldValue.key}</h4>
+ *       <div>Version {oldValue.lixcol_version_id}: {oldValue.value}</div>
+ *       <div>Version {newValue.lixcol_version_id}: {newValue.value}</div>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export type StateAll<T> = LixSelectable<EntityStateAllView<T>>;
+/**
+ * Type for querying entity history.
+ *
+ * This type unwraps all LixGenerated markers and includes historical tracking
+ * columns like change_id, change_set_id, and depth. Use this for blame
+ * functionality and understanding how entities evolved.
+ *
+ * History queries are read-only.
+ *
+ * @example
+ * ```typescript
+ * // Use StateHistory for blame UI
+ * interface BlameViewProps {
+ *   history: StateHistory<KeyValue>[];
+ * }
+ *
+ * function BlameView({ history }: BlameViewProps) {
+ *   return (
+ *     <ul>
+ *       {history.map(state => (
+ *         <li key={state.lixcol_change_id}>
+ *           <strong>Depth {state.lixcol_depth}:</strong> {state.value}
+ *           <br />
+ *           <small>Change: {state.lixcol_change_id}</small>
+ *         </li>
+ *       ))}
+ *     </ul>
+ *   );
+ * }
+ * ```
+ */
+export type StateHistory<T> = LixSelectable<EntityStateHistoryView<T>>;
+/**
+ * Type for creating new entities in the active version.
+ *
+ * This type makes all LixGenerated columns optional (like id, timestamps),
+ * while keeping other required fields mandatory. The database will
+ * automatically populate generated fields if not provided.
+ *
+ * @example
+ * ```typescript
+ * // Use NewState for form data types
+ * interface SettingsFormData {
+ *   setting: NewState<KeyValue>;
+ * }
+ *
+ * async function createSetting(formData: SettingsFormData) {
+ *   // Only key and value are required
+ *   const newSetting: NewState<KeyValue> = {
+ *     key: formData.setting.key,
+ *     value: formData.setting.value
+ *     // lixcol_created_at, lixcol_file_id etc. are auto-generated
+ *   };
+ *
+ *   await lix.db
+ *     .insertInto("key_value")
+ *     .values(newSetting)
+ *     .execute();
+ * }
+ * ```
+ */
+export type NewState<T> = LixInsertable<EntityStateView<T>>;
+/**
+ * Type for updating entities in the active version.
+ *
+ * This type makes all columns optional, allowing partial updates.
+ * Only include the fields you want to change - the database will
+ * preserve existing values for omitted fields.
+ *
+ * @example
+ * ```typescript
+ * // Use StateUpdate for update form data
+ * interface UpdateSettingData {
+ *   updates: StateUpdate<KeyValue>;
+ * }
+ *
+ * async function updateSetting(key: string, updates: UpdateSettingData) {
+ *   // Only update the fields that changed
+ *   const patch: StateUpdate<KeyValue> = {
+ *     value: updates.updates.value
+ *     // key, timestamps, etc. remain unchanged
+ *   };
+ *
+ *   await lix.db
+ *     .updateTable("key_value")
+ *     .set(patch)
+ *     .where("key", "=", key)
+ *     .execute();
+ * }
+ * ```
+ */
+export type StateUpdate<T> = LixUpdateable<EntityStateView<T>>;
+/**
+ * Type for creating new entities with version control.
+ *
+ * This type includes lixcol_version_id for creating entities in specific
+ * versions. Like NewState, it makes LixGenerated columns optional.
+ *
+ * @example
+ * ```typescript
+ * // Use NewStateAll for version-specific creation
+ * async function createFeatureFlag(versionId: string, flag: {
+ *   key: string;
+ *   value: boolean;
+ * }) {
+ *   const newFlag: NewStateAll<KeyValue> = {
+ *     key: flag.key,
+ *     value: flag.value,
+ *     lixcol_version_id: versionId  // Create in specific version
+ *   };
+ *
+ *   await lix.db
+ *     .insertInto("key_value_all")
+ *     .values(newFlag)
+ *     .execute();
+ * }
+ * ```
+ */
+export type NewStateAll<T> = LixInsertable<EntityStateAllView<T>>;
+/**
+ * Type for updating entities in specific versions.
+ *
+ * This type makes all columns optional for partial updates and includes
+ * version control. You can update entities in any version or change
+ * an entity's version.
+ *
+ * @example
+ * ```typescript
+ * // Use StateAllUpdate for version-specific updates
+ * async function toggleFeatureFlag(
+ *   key: string,
+ *   versionId: string,
+ *   enabled: boolean
+ * ) {
+ *   const updates: StateAllUpdate<KeyValue> = {
+ *     value: enabled
+ *   };
+ *
+ *   await lix.db
+ *     .updateTable("key_value_all")
+ *     .set(updates)
+ *     .where("key", "=", key)
+ *     .where("lixcol_version_id", "=", versionId)
+ *     .execute();
+ * }
+ * ```
+ */
+export type StateAllUpdate<T> = LixUpdateable<EntityStateAllView<T>>;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/entity-views/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/entity-views/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AACnE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAC5D,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAC;AAC3E,OAAO,KAAK,EAAE,SAAS,IAAI,eAAe,EAAE,MAAM,QAAQ,CAAC;AAC3D,OAAO,KAAK,EACX,YAAY,EACZ,aAAa,EACb,aAAa,EACb,aAAa,EACb,MAAM,oCAAoC,CAAC;AAE5C;;GAEG;AACH,KAAK,cAAc,CAAC,CAAC,IAAI,CAAC,SAAS;IAAE,QAAQ,CAAC,cAAc,CAAC,EAAE,IAAI,CAAA;CAAE,GAClE,IAAI,GACJ,KAAK,CAAC;AAET;;;GAGG;AACH,KAAK,oBAAoB,CAAC,CAAC,IAAI,CAAC,SAAS,YAAY,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAEvE;;GAEG;AACH,KAAK,UAAU,CAAC,CAAC,IAAI,oBAAoB,CAAC,CAAC,CAAC,CAAC;AAE7C;;;GAGG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI;KACxB,CAAC,IAAI,MAAM,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,IAAI,GAC9C,eAAe,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GACjC,CAAC,CAAC,CAAC,CAAC;CACP,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI,CAAC,GAAG,kBAAkB,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,MAAM,kBAAkB,CAAC,CAAC,IAAI,CAAC,GAAG,qBAAqB,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,MAAM,sBAAsB,CAAC,CAAC,IAAI,CAAC,GAAG,yBAAyB,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,MAAM,KAAK,CAAC,CAAC,IAAI,aAAa,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,aAAa,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,aAAa,CAAC,sBAAsB,CAAC,CAAC,CAAC,CAAC,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,aAAa,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,aAAa,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,aAAa,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC;AAElE;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI,aAAa,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC"}

package/dist/entity-views/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/entity-views/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/entity-views/types.ts"],"names":[],"mappings":""}

package/dist/entity-views/types.test.d.ts

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

package/dist/entity-views/types.test.d.ts.map

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

package/dist/entity-views/types.test.js

@@ -0,0 +1,62 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { test } from "vitest";
+test("ToKysely converts LixGenerated to Kysely Generated", () => {
+    // Verify the conversion is correct by creating a type-compatible object
+    const kyselyTable = {
+        id: {},
+        name: "test",
+        count: {},
+        metadata: { foo: "bar" },
+        optional: null,
+    };
+    // These should work
+    const id = {};
+    const name = "test";
+    const count = {};
+    const metadata = { foo: "test" };
+    const optional1 = "value";
+    const optional2 = null;
+    const optional3 = undefined;
+});
+test("LixGenerated markers work with NewState", () => {
+    // Define a mock schema with x-lix-generated
+    const MockEntitySchema = {
+        "x-lix-key": "mock_entity",
+        "x-lix-version": "1.0",
+        "x-lix-primary-key": ["id"],
+        type: "object",
+        properties: {
+            id: { type: "string", "x-lix-generated": true },
+            name: { type: "string" },
+            count: { type: "number", "x-lix-generated": true },
+            optional_field: { type: "string", nullable: true },
+        },
+        required: ["id", "name", "count"],
+        additionalProperties: false,
+    };
+    // Test that NewState makes generated fields optional
+    const newMockEntity = {
+        name: "test-name",
+        // id should be optional because it's LixGenerated
+        // count should be optional because it's LixGenerated
+        // optional_field should be optional because it's nullable
+    };
+    // Test that NewState also accepts generated fields when provided
+    const newMockEntityWithGenerated = {
+        id: "custom-id",
+        name: "test-name",
+        count: 42,
+        optional_field: "optional",
+    };
+    // Test that required non-generated fields are still required
+    // @ts-expect-error - name is required
+    const invalidNewMockEntity = {
+        count: 42,
+        // Missing required field 'name'
+    };
+    // Verify the types work as expected
+    void newMockEntity;
+    void newMockEntityWithGenerated;
+    void invalidNewMockEntity;
+});
+//# sourceMappingURL=types.test.js.map

package/dist/entity-views/types.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.test.js","sourceRoot":"","sources":["../../src/entity-views/types.test.ts"],"names":[],"mappings":"AAAA,sDAAsD;AACtD,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAY9B,IAAI,CAAC,oDAAoD,EAAE,GAAG,EAAE;IAY/D,wEAAwE;IACxE,MAAM,WAAW,GAAkB;QAClC,EAAE,EAAE,EAA6B;QACjC,IAAI,EAAE,MAAM;QACZ,KAAK,EAAE,EAA6B;QACpC,QAAQ,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE;QACxB,QAAQ,EAAE,IAAI;KACd,CAAC;IASF,oBAAoB;IACpB,MAAM,EAAE,GAAW,EAA6B,CAAC;IACjD,MAAM,IAAI,GAAa,MAAM,CAAC;IAC9B,MAAM,KAAK,GAAc,EAA6B,CAAC;IACvD,MAAM,QAAQ,GAAiB,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC;IAC/C,MAAM,SAAS,GAAiB,OAAO,CAAC;IACxC,MAAM,SAAS,GAAiB,IAAI,CAAC;IACrC,MAAM,SAAS,GAAiB,SAAS,CAAC;AAC3C,CAAC,CAAC,CAAC;AAEH,IAAI,CAAC,yCAAyC,EAAE,GAAG,EAAE;IACpD,4CAA4C;IAC5C,MAAM,gBAAgB,GAAG;QACxB,WAAW,EAAE,aAAa;QAC1B,eAAe,EAAE,KAAK;QACtB,mBAAmB,EAAE,CAAC,IAAI,CAAC;QAC3B,IAAI,EAAE,QAAQ;QACd,UAAU,EAAE;YACX,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,iBAAiB,EAAE,IAAI,EAAE;YAC/C,IAAI,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;YACxB,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,iBAAiB,EAAE,IAAI,EAAE;YAClD,cAAc,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE;SAClD;QACD,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC;QACjC,oBAAoB,EAAE,KAAK;KACY,CAAC;IAKzC,qDAAqD;IACrD,MAAM,aAAa,GAAyB;QAC3C,IAAI,EAAE,WAAW;QACjB,kDAAkD;QAClD,qDAAqD;QACrD,0DAA0D;KAC1D,CAAC;IAEF,iEAAiE;IACjE,MAAM,0BAA0B,GAAyB;QACxD,EAAE,EAAE,WAAW;QACf,IAAI,EAAE,WAAW;QACjB,KAAK,EAAE,EAAE;QACT,cAAc,EAAE,UAAU;KAC1B,CAAC;IAEF,6DAA6D;IAC7D,sCAAsC;IACtC,MAAM,oBAAoB,GAAyB;QAClD,KAAK,EAAE,EAAE;QACT,gCAAgC;KAChC,CAAC;IAEF,oCAAoC;IACpC,KAAK,aAAa,CAAC;IACnB,KAAK,0BAA0B,CAAC;IAChC,KAAK,oBAAoB,CAAC;AAC3B,CAAC,CAAC,CAAC"}

package/dist/file/file-handlers.d.ts

@@ -0,0 +1,15 @@
+import type { LixFile } from "./schema.js";
+import type { Lix } from "../lix/open-lix.js";
+export declare function handleFileInsert(args: {
+    lix: Pick<Lix, "sqlite" | "plugin" | "db" | "hooks">;
+    file: LixFile;
+    versionId: string;
+    untracked?: boolean;
+}): 0 | 1;
+export declare function handleFileUpdate(args: {
+    lix: Pick<Lix, "sqlite" | "plugin" | "db" | "hooks">;
+    file: LixFile;
+    versionId: string;
+    untracked?: boolean;
+}): 0 | 1;
+//# sourceMappingURL=file-handlers.d.ts.map

package/dist/file/file-handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-handlers.d.ts","sourceRoot":"","sources":["../../src/file/file-handlers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAG3C,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,oBAAoB,CAAC;AAoB9C,wBAAgB,gBAAgB,CAAC,IAAI,EAAE;IACtC,GAAG,EAAE,IAAI,CAAC,GAAG,EAAE,QAAQ,GAAG,QAAQ,GAAG,IAAI,GAAG,OAAO,CAAC,CAAC;IACrD,IAAI,EAAE,OAAO,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,CAAC;CACpB,GAAG,CAAC,GAAG,CAAC,CAgJR;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE;IACtC,GAAG,EAAE,IAAI,CAAC,GAAG,EAAE,QAAQ,GAAG,QAAQ,GAAG,IAAI,GAAG,OAAO,CAAC,CAAC;IACrD,IAAI,EAAE,OAAO,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,CAAC;CACpB,GAAG,CAAC,GAAG,CAAC,CAuLR"}