@lix-js/sdk 0.5.1 → 0.6.0-preview.1

package/src/stored-schema/get-stored-schema.ts

@@ -1,163 +0,0 @@
-import { sql } from "kysely";
-import type { LixEngine } from "../engine/boot.js";
-import type { LixSchemaDefinition } from "../schema-definition/definition.js";
-import { LixStoredSchemaSchema } from "./schema-definition.js";
-import { internalQueryBuilder } from "../engine/internal-query-builder.js";
-
-type StoredSchemaCache = {
-	byKey: Map<string, LixSchemaDefinition | null>;
-	all?: { definitions: Map<string, LixSchemaDefinition>; signature: string };
-};
-
-const cache = new WeakMap<object, StoredSchemaCache>();
-const subscriptions = new WeakMap<object, () => void>();
-
-/**
- * Loads the most recent stored schema definition for the exact key provided.
- *
- * The lookup targets the `global` version only and does not apply any prefixing
- * or aliasing to `key`. Results are cached per-engine and invalidated on state
- * commits that modify stored schemas. Returns `null` if the schema cannot be
- * found.
- *
- * @example
- * ```ts
- * const schema = getStoredSchema({ engine, key: "lix_change_set" });
- * console.log(schema?.["x-lix-version"]);
- * ```
- */
-export function getStoredSchema(args: {
-	engine: Pick<LixEngine, "executeSync" | "runtimeCacheRef" | "hooks">;
-	key: string;
-}): LixSchemaDefinition | null {
-	const { engine, key } = args;
-	if (!key) return null;
-
-	ensureSubscription(engine);
-	const cacheEntry = ensureCache(engine.runtimeCacheRef);
-	if (cacheEntry.byKey.has(key)) {
-		return cacheEntry.byKey.get(key) ?? null;
-	}
-
-	const schema = loadSchema(engine, key);
-	cacheEntry.byKey.set(key, schema);
-	return schema;
-}
-
-export function getAllStoredSchemas(args: {
-	engine: Pick<LixEngine, "executeSync" | "runtimeCacheRef" | "hooks">;
-}): { definitions: Map<string, LixSchemaDefinition>; signature: string } {
-	const { engine } = args;
-	ensureSubscription(engine);
-	const cacheEntry = ensureCache(engine.runtimeCacheRef);
-	if (cacheEntry.all) {
-		return cacheEntry.all;
-	}
-
-	const compiledQuery = internalQueryBuilder
-		.selectFrom("lix_internal_state_vtable")
-		.select(["snapshot_content", "updated_at"])
-		.where("schema_key", "=", LixStoredSchemaSchema["x-lix-key"])
-		.where("snapshot_content", "is not", null)
-		.where("version_id", "=", "global")
-		.compile();
-
-	const { rows } = engine.executeSync({
-		...compiledQuery,
-		preprocessMode: "vtable-select-only",
-	});
-
-	const definitions = new Map<string, LixSchemaDefinition>();
-	let maxUpdated = "";
-
-	for (const row of rows as Array<Record<string, unknown>>) {
-		const parsed = JSON.parse(String(row.snapshot_content));
-		const updatedAt = String(row.updated_at ?? "");
-		const definition = parsed.value as LixSchemaDefinition;
-		if (!definition || typeof definition !== "object") {
-			continue;
-		}
-		registerDefinition(cacheEntry, definition);
-		const key = definition["x-lix-key"];
-		if (typeof key !== "string" || key.length === 0) {
-			continue;
-		}
-		definitions.set(key, definition);
-		if (updatedAt > maxUpdated) {
-			maxUpdated = updatedAt;
-		}
-	}
-
-	const signature = `${definitions.size}:${maxUpdated}`;
-	cacheEntry.all = { definitions, signature };
-	return cacheEntry.all;
-}
-
-function loadSchema(
-	engine: Pick<LixEngine, "executeSync" | "runtimeCacheRef">,
-	key: string
-): LixSchemaDefinition | null {
-	const compiledQuery = internalQueryBuilder
-		.selectFrom("lix_internal_state_vtable")
-		.select(sql`json_extract(snapshot_content, '$.value')`.as("value"))
-		.where("schema_key", "=", LixStoredSchemaSchema["x-lix-key"])
-		.where(sql`json_extract(snapshot_content, '$.value."x-lix-key"')`, "=", key)
-		.where("version_id", "=", "global")
-		.where("snapshot_content", "is not", null)
-		.orderBy(
-			sql`json_extract(snapshot_content, '$.value."x-lix-version"')`,
-			"desc"
-		)
-		.limit(1)
-		.compile();
-
-	const { rows } = engine.executeSync({
-		...compiledQuery,
-		preprocessMode: "vtable-select-only",
-	});
-	const raw = rows[0]?.value;
-	if (typeof raw !== "string") return null;
-	const definition = JSON.parse(raw) as LixSchemaDefinition;
-	if (definition) {
-		registerDefinition(ensureCache(engine.runtimeCacheRef), definition);
-	}
-	return definition;
-}
-
-function ensureCache(ref: object): StoredSchemaCache {
-	let entry = cache.get(ref);
-	if (!entry) {
-		entry = { byKey: new Map(), all: undefined };
-		cache.set(ref, entry);
-	}
-	return entry;
-}
-
-function registerDefinition(
-	cacheEntry: StoredSchemaCache,
-	definition: LixSchemaDefinition
-): void {
-	const key = definition["x-lix-key"];
-	if (typeof key === "string" && key.length > 0) {
-		cacheEntry.byKey.set(key, definition);
-	}
-}
-
-function ensureSubscription(
-	engine: Pick<LixEngine, "runtimeCacheRef" | "hooks">
-): void {
-	if (!engine.hooks) return;
-	if (subscriptions.has(engine.runtimeCacheRef)) return;
-
-	const unsubscribe = engine.hooks.onStateCommit(({ changes }) => {
-		if (!changes || changes.length === 0) return;
-		for (const change of changes) {
-			if (change.schema_key === LixStoredSchemaSchema["x-lix-key"]) {
-				cache.delete(engine.runtimeCacheRef);
-				break;
-			}
-		}
-	});
-
-	subscriptions.set(engine.runtimeCacheRef, unsubscribe);
-}

package/src/stored-schema/index.ts

@@ -1,4 +0,0 @@
-export {
-	LixStoredSchemaSchema,
-	type LixStoredSchema as StoredSchema,
-} from "./schema-definition.js";

package/src/stored-schema/schema-definition.ts

@@ -1,30 +0,0 @@
-import type {
-	FromLixSchemaDefinition,
-	LixSchemaDefinition,
-} from "../schema-definition/definition.js";
-import { JSONTypeSchema } from "../schema-definition/json-type.js";
-
-export type LixStoredSchema = FromLixSchemaDefinition<
-	typeof LixStoredSchemaSchema
-> & {
-	value: LixSchemaDefinition;
-};
-
-export const LixStoredSchemaSchema = {
-	"x-lix-key": "lix_stored_schema",
-	"x-lix-version": "1.0",
-	"x-lix-primary-key": ["/value/x-lix-key", "/value/x-lix-version"],
-	"x-lix-immutable": true,
-	"x-lix-override-lixcols": {
-		lixcol_file_id: '"lix"',
-		lixcol_plugin_key: '"lix_sdk"',
-		lixcol_version_id: '"global"',
-	},
-	type: "object",
-	properties: {
-		value: JSONTypeSchema as any,
-	},
-	required: ["value"],
-	additionalProperties: false,
-} as const;
-LixStoredSchemaSchema satisfies LixSchemaDefinition;

package/src/stored-schema/schema.test.ts

@@ -1,198 +0,0 @@
-import { test, expect } from "vitest";
-import { openLix } from "../lix/open-lix.js";
-import type { LixSchemaDefinition } from "../schema-definition/definition.js";
-import type { NewState } from "../engine/entity-views/types.js";
-import type { LixStoredSchema } from "./schema-definition.js";
-import { sql } from "kysely";
-
-test("insert and delete a stored schema", async () => {
-	const lix = await openLix({});
-
-	const schema: NewState<LixStoredSchema> = {
-		value: {
-			type: "object",
-			"x-lix-key": "mock",
-			"x-lix-version": "1.0",
-			properties: {
-				name: { type: "string" },
-			},
-			required: ["name"],
-			additionalProperties: false,
-		},
-	};
-
-	await lix.db.insertInto("stored_schema").values(schema).execute();
-
-	const afterInsert = await lix.db
-		.selectFrom("stored_schema")
-		.select("value")
-		.where(
-			sql`json_extract("stored_schema"."value", '$."x-lix-key"')`,
-			"=",
-			"mock"
-		)
-		.where(
-			sql`json_extract("stored_schema"."value", '$."x-lix-version"')`,
-			"=",
-			"1.0"
-		)
-		.executeTakeFirst();
-
-	expect(afterInsert?.value).toEqual(schema.value);
-
-	await lix.db
-		.deleteFrom("stored_schema")
-		.where("lixcol_entity_id", "=", "mock~1.0")
-		.execute();
-
-	const afterDelete = await lix.db
-		.selectFrom("stored_schema")
-		.select("value")
-		.where(
-			sql`json_extract("stored_schema"."value", '$."x-lix-key"')`,
-			"=",
-			"mock"
-		)
-		.where(
-			sql`json_extract("stored_schema"."value", '$."x-lix-version"')`,
-			"=",
-			"1.0"
-		)
-		.execute();
-
-	expect(afterDelete).toHaveLength(0);
-});
-
-test("updating is not possible (schema is immutable, needs new version bumb)", async () => {
-	const lix = await openLix({});
-
-	const schema: NewState<LixStoredSchema> = {
-		value: {
-			type: "object",
-			"x-lix-key": "mock",
-			"x-lix-version": "1.0",
-			properties: {
-				name: { type: "string" },
-			},
-			required: ["name"],
-			additionalProperties: false,
-		},
-	};
-
-	await lix.db.insertInto("stored_schema").values(schema).execute();
-
-	await expect(
-		lix.db
-			.updateTable("stored_schema")
-			.set({
-				value: {
-					...(schema.value as Record<string, unknown>),
-					"x-lix-version": "2.0",
-				},
-			})
-			.execute()
-	).rejects.toThrow(/immutable/);
-});
-
-test("validates inserted schemas", async () => {
-	const lix = await openLix({});
-
-	const schema: any = {
-		value: {
-			type: "object",
-			"x-lix-key": "mock",
-			// intentionally invalid version type
-			"x-lix-version": 1,
-			properties: {
-				name: { type: "string" },
-			},
-			required: ["name"],
-			additionalProperties: false,
-		},
-	};
-
-	await expect(
-		lix.db.insertInto("stored_schema").values(schema).execute()
-	).rejects.toThrow(/value\.x-lix-version must be string/);
-});
-
-test("can insert into stored_schema_by_version ", async () => {
-	const lix = await openLix({});
-
-	const schema: LixSchemaDefinition = {
-		type: "object",
-		"x-lix-key": "mock_by_version",
-		"x-lix-version": "1.0",
-		properties: {
-			name: { type: "string" },
-		},
-		required: ["name"],
-		additionalProperties: false,
-	};
-
-	await lix.db
-		.insertInto("stored_schema_by_version")
-		.values({
-			value: schema,
-			lixcol_version_id: "global",
-		})
-		.execute();
-
-	const result = await lix.db
-		.selectFrom("stored_schema_by_version")
-		.select("value")
-		.where(
-			sql`json_extract("stored_schema_by_version"."value", '$."x-lix-key"')`,
-			"=",
-			"mock_by_version"
-		)
-		.where(
-			sql`json_extract("stored_schema_by_version"."value", '$."x-lix-version"')`,
-			"=",
-			"1.0"
-		)
-		.executeTakeFirstOrThrow();
-
-	expect(result.value).toEqual(schema);
-});
-
-test("can insert into stored_schema_by_version with default key and version extraction", async () => {
-	const lix = await openLix({});
-
-	const schema: LixSchemaDefinition = {
-		type: "object",
-		"x-lix-key": "mock_extract",
-		"x-lix-version": "2.0",
-		properties: {
-			name: { type: "string" },
-		},
-		required: ["name"],
-		additionalProperties: false,
-	};
-
-	// Insert without key and version - should be extracted from value
-	await lix.db
-		.insertInto("stored_schema_by_version")
-		.values({
-			value: schema,
-			lixcol_version_id: "global",
-		})
-		.execute();
-
-	const result = await lix.db
-		.selectFrom("stored_schema_by_version")
-		.select("value")
-		.where(
-			sql`json_extract("stored_schema_by_version"."value", '$."x-lix-key"')`,
-			"=",
-			"mock_extract"
-		)
-		.where(
-			sql`json_extract("stored_schema_by_version"."value", '$."x-lix-version"')`,
-			"=",
-			"2.0"
-		)
-		.executeTakeFirstOrThrow();
-
-	expect(result.value).toEqual(schema);
-});

package/src/sync/get-diffing-rows.ts

@@ -1,112 +0,0 @@
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-nocheck
-
-import type { Lix } from "../lix/open-lix.js";
-import type { VectorClock } from "./merge-state.js";
-
-/**
- * Collects all database rows that differ from a target state.
- *
- * The returned rows can be upserted on the target to synchronise two
- * Lix instances. The current vector clock of this Lix file is also
- * returned to let the remote side calculate its own diff.
- *
- * @example
- * ```ts
- * const { upsertedRows } = await getDiffingRows({ lix, targetVectorClock })
- * ```
- */
-
-export async function getDiffingRows(args: {
-	/**
-	 * the lix to merge their state into
-	 */
-	lix: Pick<Lix, "db">;
-	/**
-	 * the the vector clock of the lix to merge in
-	 */
-	targetVectorClock: VectorClock;
-}): Promise<{
-	state: any;
-	upsertedRows: Record<string, any[]>;
-}> {
-	const upsertedRows: Record<string, any[]> = {};
-
-	let state: VectorClock = [];
-
-	const executeInTransaction = async (trx: Lix["db"]) => {
-		state = await trx
-			.selectFrom("mutation_log")
-			.select(({ fn }) => {
-				return ["session", fn.max<number>("session_time").as("time")];
-			})
-			.groupBy("session")
-			.execute();
-		// use the target vector clock to collect all changed rows the target is not aware of
-		let operationsToPush = trx
-			.selectFrom("mutation_log")
-			.selectAll("mutation_log");
-
-		if (args.targetVectorClock.length > 0) {
-			operationsToPush = operationsToPush.where((eb) => {
-				const knownSessions = args.targetVectorClock.map(
-					(sessionTime) => sessionTime.session
-				);
-
-				const ors: any[] = [];
-				ors.push(eb("session", "not in", knownSessions));
-				for (const sessionTime of args.targetVectorClock) {
-					ors.push(
-						eb("session", "=", sessionTime.session).and(
-							"session_time",
-							">",
-							sessionTime.time
-						)
-					);
-				}
-
-				return eb.or(ors) as any;
-			});
-		}
-
-		upsertedRows["mutation_log"] = await operationsToPush.execute();
-
-		// console.log("upsertedRows", upsertedRows);
-
-		for (const operation of upsertedRows["mutation_log"]) {
-			const tableName = operation.table_name;
-			if (upsertedRows[tableName] === undefined) {
-				upsertedRows[tableName] = [];
-			}
-			if (tableName === "snapshot") {
-				// ignore inserted column id
-				upsertedRows[tableName].push(
-					await trx
-						.selectFrom(tableName)
-						.selectAll()
-						.where("id", "=", operation.row_id["id"])
-						.executeTakeFirstOrThrow()
-				);
-			} else {
-				let diffRow = trx.selectFrom(tableName).selectAll();
-
-				for (const [key, value] of Object.entries(operation.row_id)) {
-					diffRow = diffRow.where(key, "=", value);
-				}
-
-				upsertedRows[tableName].push(await diffRow.executeTakeFirstOrThrow());
-			}
-		}
-	};
-
-	if (args.lix.db.isTransaction) {
-		await executeInTransaction(args.lix.db);
-	} else {
-		await args.lix.db.transaction().execute(executeInTransaction);
-	}
-
-	return {
-		state,
-		upsertedRows,
-	};
-}