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

package/src/engine/explain-query.ts

@@ -1,89 +0,0 @@
-import type { LixEngine } from "./boot.js";
-import {
-	createSchemaCacheTable,
-	schemaKeyToCacheTableName,
-} from "../state/cache/create-schema-cache-table.js";
-import { getStateCacheTables } from "../state/cache/schema.js";
-import { listAvailableCacheSchemas } from "../state/cache/schema-resolver.js";
-import type { LixSchemaDefinition } from "../schema-definition/definition.js";
-
-type ExplainQueryStage = {
-	originalSql: string;
-	parameters: unknown[];
-	rewrittenSql?: string;
-	plan: any[];
-};
-
-export function createExplainQuery(args: {
-	engine: Pick<
-		LixEngine,
-		"sqlite" | "hooks" | "runtimeCacheRef" | "preprocessQuery" | "executeSync"
-	>;
-}): (args: { sql: string; parameters: any[] }) => ExplainQueryStage {
-	const preprocess = args.engine.preprocessQuery;
-
-	return ({ sql, parameters }) => {
-		const result = preprocess({
-			sql,
-			parameters,
-			// sideEffects removed false,
-		});
-
-		ensureCacheTablesForSql(args.engine, result.sql);
-		const trimmed = result.sql.trimStart();
-		const needsWrapper = trimmed.startsWith("(");
-		// Wrap the rewritten SQL in a trivial CTE only when we end up with a bare derived table.
-		// SQLite refuses to EXPLAIN `(…) AS alias`, but regular INSERT/UPDATE/SELECT statements
-		// should be explained as-is.
-		const explainTarget = needsWrapper
-			? `WITH __lix_explain_target AS (${result.sql}) SELECT * FROM __lix_explain_target`
-			: result.sql;
-		const explainRows = args.engine.sqlite.exec({
-			sql: `EXPLAIN QUERY PLAN ${explainTarget}`,
-			bind: result.parameters as any[],
-			returnValue: "resultRows",
-			rowMode: "object",
-			columnNames: [],
-		}) as any[];
-
-		const wasRewritten = result.sql !== sql;
-
-		return {
-			originalSql: sql,
-			parameters,
-			rewrittenSql: wasRewritten ? result.sql : undefined,
-			plan: explainRows,
-		};
-	};
-}
-
-function ensureCacheTablesForSql(
-	engine: Pick<LixEngine, "executeSync" | "runtimeCacheRef" | "hooks">,
-	sql: string
-): void {
-	const matches = sql.matchAll(/lix_internal_state_cache_([A-Za-z0-9_]+)/g);
-	const tableCache = getStateCacheTables({ engine });
-	const availableSchemas = listAvailableCacheSchemas({ engine });
-	const tableToSchema = new Map<string, LixSchemaDefinition>();
-	for (const [schemaKey, definition] of availableSchemas.entries()) {
-		const tableName = schemaKeyToCacheTableName(schemaKey);
-		tableToSchema.set(tableName, definition);
-	}
-	for (const match of matches) {
-		const tableName = match[0];
-		if (!tableName) continue;
-		if (tableCache.has(tableName)) continue;
-		const schemaDefinition = tableToSchema.get(tableName);
-		if (!schemaDefinition) {
-			continue;
-		}
-		const created = createSchemaCacheTable({
-			engine,
-			schema: schemaDefinition,
-		});
-		tableCache.add(created);
-		if (created !== tableName) {
-			tableCache.add(tableName);
-		}
-	}
-}

package/src/engine/functions/function-registry.ts

@@ -1,69 +0,0 @@
-import type { LixEngine } from "../boot.js";
-
-export type Call = (name: string, args?: unknown) => any;
-
-export type FunctionHandlerContext = {
-	engine: Pick<
-		LixEngine,
-		| "sqlite"
-		| "hooks"
-		| "executeSync"
-		| "runtimeCacheRef"
-		| "call"
-		| "preprocessQuery"
-	>;
-};
-
-export type RegisteredFunctionDefinition = {
-	name: string;
-	handler: (ctx: FunctionHandlerContext, args: any) => any;
-};
-
-export type FunctionRegistry = {
-	register: (def: RegisteredFunctionDefinition) => void;
-	call: Call;
-	list: () => readonly { name: string }[];
-};
-
-type RegisteredFunction = {
-	handler: RegisteredFunctionDefinition["handler"];
-};
-
-export function createFunctionRegistry(args: {
-	engine: Pick<
-		LixEngine,
-		| "sqlite"
-		| "hooks"
-		| "executeSync"
-		| "runtimeCacheRef"
-		| "call"
-		| "preprocessQuery"
-	>;
-}): FunctionRegistry {
-	const functions = new Map<string, RegisteredFunction>();
-
-	const register = (def: RegisteredFunctionDefinition): void => {
-		if (functions.has(def.name)) {
-			throw new Error(`Function "${def.name}" is already registered.`);
-		}
-		functions.set(def.name, { handler: def.handler });
-	};
-
-	const call: Call = (name, argsValue) => {
-		const entry = functions.get(name);
-		if (!entry) {
-			const err: any = new Error(`Unknown function: ${name}`);
-			err.code = "LIX_CALL_UNKNOWN";
-			throw err;
-		}
-		return entry.handler({ engine: args.engine }, argsValue);
-	};
-
-	const list = () => Array.from(functions.keys(), (name) => ({ name }));
-
-	return {
-		register,
-		call,
-		list,
-	};
-}

package/src/engine/functions/generate-human-id.test.ts

@@ -1,199 +0,0 @@
-import { test, expect } from "vitest";
-import {
-	humanId,
-	deterministicHumanIdVocabularySize,
-} from "./generate-human-id.js";
-import { openLix } from "../../lix/open-lix.js";
-
-test("returns deterministic names in deterministic mode", async () => {
-	// Open two separate lix instances with deterministic mode
-	const lix1 = await openLix({
-		keyValues: [{ key: "lix_deterministic_mode", value: { enabled: true } }],
-	});
-	const lix2 = await openLix({
-		keyValues: [{ key: "lix_deterministic_mode", value: { enabled: true } }],
-	});
-
-	// Generate IDs from both instances - they should match
-	const id1_lix1 = await humanId({ lix: lix1 });
-	const id1_lix2 = await humanId({ lix: lix2 });
-
-	const id2_lix1 = await humanId({ lix: lix1 });
-	const id2_lix2 = await humanId({ lix: lix2 });
-
-	const id3_lix1 = await humanId({ lix: lix1 });
-	const id3_lix2 = await humanId({ lix: lix2 });
-
-	// Both instances should generate the same sequence
-	expect(id1_lix1).toBe(id1_lix2);
-	expect(id2_lix1).toBe(id2_lix2);
-	expect(id3_lix1).toBe(id3_lix2);
-});
-
-test("cycles through names when exceeding array length", async () => {
-	const lix = await openLix({
-		keyValues: [{ key: "lix_deterministic_mode", value: { enabled: true } }],
-	});
-
-	// Generate many IDs to test cycling
-	const names: string[] = [];
-	const vocabSize = deterministicHumanIdVocabularySize();
-	for (let i = 0; i < vocabSize + 5; i++) {
-		names.push(await humanId({ lix }));
-	}
-
-	// Find where the cycle starts repeating
-	let firstRepeatIndex = -1;
-	for (let i = 1; i < names.length; i++) {
-		if (names[i] === names[0]) {
-			firstRepeatIndex = i;
-			break;
-		}
-	}
-
-	// Should cycle after the vocabulary size
-	expect(firstRepeatIndex).toBe(vocabSize);
-
-	// Verify cycling pattern
-	expect(names[vocabSize]).toBe(names[0]);
-	expect(names[vocabSize + 1]).toBe(names[1]);
-	expect(names[vocabSize + 2]).toBe(names[2]);
-});
-
-test("returns non-deterministic names in normal mode", async () => {
-	const lix = await openLix({
-		keyValues: [{ key: "lix_deterministic_mode", value: { enabled: false } }],
-	});
-
-	const id1 = await humanId({ lix });
-	const id2 = await humanId({ lix });
-
-	// Names should be strings
-	expect(typeof id1).toBe("string");
-	expect(typeof id2).toBe("string");
-
-	// Names should not be empty
-	expect(id1.length).toBeGreaterThan(0);
-	expect(id2.length).toBeGreaterThan(0);
-
-	// Names should be capitalized
-	expect(id1[0]).toBe(id1[0]?.toUpperCase());
-	expect(id2[0]).toBe(id2[0]?.toUpperCase());
-
-	// Default separator should yield multi-word identifiers
-	const parts = id1.split("_");
-	expect(parts.length).toBeGreaterThanOrEqual(2);
-	for (const part of parts) {
-		expect(part.length).toBeGreaterThan(0);
-	}
-});
-
-test("respects lowercase option in non-deterministic mode", async () => {
-	const lix = await openLix({
-		keyValues: [{ key: "lix_deterministic_mode", value: { enabled: false } }],
-	});
-
-	const id = await humanId({ lix, capitalize: false });
-
-	expect(id).toBe(id.toLowerCase());
-	expect(id.length).toBeGreaterThan(0);
-});
-
-test("uses custom separator when provided", async () => {
-	const lix = await openLix({
-		keyValues: [{ key: "lix_deterministic_mode", value: { enabled: false } }],
-	});
-
-	const idWithDash = await humanId({ lix, separator: "-" });
-	const idWithSpace = await humanId({ lix, separator: " " });
-	const idWithUnderscore = await humanId({ lix, separator: "_" });
-
-	// All should be strings
-	expect(typeof idWithDash).toBe("string");
-	expect(typeof idWithSpace).toBe("string");
-	expect(typeof idWithUnderscore).toBe("string");
-
-	// Non-empty separators should appear between components
-	const dashParts = idWithDash.split("-");
-	expect(dashParts.length).toBeGreaterThanOrEqual(2);
-	expect(idWithDash.startsWith("-")).toBe(false);
-	expect(idWithDash.endsWith("-")).toBe(false);
-
-	const spaceParts = idWithSpace.trim().split(" ");
-	expect(spaceParts.length).toBeGreaterThanOrEqual(2);
-	expect(idWithSpace.startsWith(" ")).toBe(false);
-	expect(idWithSpace.endsWith(" ")).toBe(false);
-
-	const underscoreParts = idWithUnderscore.split("_");
-	expect(underscoreParts.length).toBeGreaterThanOrEqual(2);
-	expect(idWithUnderscore.startsWith("_")).toBe(false);
-	expect(idWithUnderscore.endsWith("_")).toBe(false);
-});
-
-test("supports empty separator for compact identifiers", async () => {
-	const lix = await openLix({
-		keyValues: [{ key: "lix_deterministic_mode", value: { enabled: false } }],
-	});
-
-	const id = await humanId({ lix, separator: "" });
-
-	expect(id.length).toBeGreaterThan(0);
-	expect(id).toMatch(/^[A-Za-z0-9]+$/);
-	expect(id[0]).toBe(id[0]?.toUpperCase());
-});
-
-test("persists sequence across lix instances", async () => {
-	// Create first lix instance
-	const lix1 = await openLix({
-		keyValues: [{ key: "lix_deterministic_mode", value: { enabled: true } }],
-	});
-
-	// Generate some IDs
-	const id1 = await humanId({ lix: lix1 });
-	const id2 = await humanId({ lix: lix1 });
-	const id3 = await humanId({ lix: lix1 });
-
-	// Get the blob
-	const blob = await lix1.toBlob();
-
-	// Create new lix instance from blob
-	const lix2 = await openLix({
-		blob,
-		keyValues: [{ key: "lix_deterministic_mode", value: { enabled: true } }],
-	});
-
-	// Generate next ID - should continue from where we left off
-	const id4 = await humanId({ lix: lix2 });
-
-	// Verify it's not repeating the sequence
-	expect(id4).not.toBe(id1);
-	expect(id4).not.toBe(id2);
-	expect(id4).not.toBe(id3);
-});
-
-test("handles capitalize option", async () => {
-	const lix = await openLix({
-		keyValues: [{ key: "lix_deterministic_mode", value: { enabled: true } }],
-	});
-
-	// Generate IDs with different capitalize options
-	const capitalizedId = await humanId({ lix, capitalize: true });
-	const lowercaseId = await humanId({ lix, capitalize: false });
-
-	// Capitalized should be uppercase first letter
-	expect(capitalizedId[0]).toBe(capitalizedId[0]?.toUpperCase());
-
-	// Lowercase should be all lowercase
-	expect(lowercaseId).toBe(lowercaseId.toLowerCase());
-});
-
-test("default capitalize is true", async () => {
-	const lix = await openLix({
-		keyValues: [{ key: "lix_deterministic_mode", value: { enabled: true } }],
-	});
-
-	const id = await humanId({ lix });
-
-	// Should be capitalized by default
-	expect(id[0]).toBe(id[0]?.toUpperCase());
-});