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

package/src/state/cache-v2/populate-state-cache.ts

@@ -1,178 +0,0 @@
-import type { LixEngine } from "../../engine/boot.js";
-import type { MaterializedState as MaterializedChange } from "../vtable/generate-commit.js";
-import { updateStateCacheV2 } from "./update-state-cache.js";
-import {
-	getStateCacheV2Tables,
-	getStateCacheV2Columns,
-	clearStateCacheV2Columns,
-} from "./schema.js";
-
-export interface PopulateStateCacheV2Options {
-	version_id?: string; // Optional - if not provided, all active versions are populated
-}
-
-/**
- * Populates the state cache v2 from the materializer view.
- *
- * This function reads from the materialized state and writes to the per-schema
- * physical cache tables. If a version_id is provided, it also populates the
- * cache for all ancestor versions.
- *
- * @param lix - The Lix instance with sqlite and db
- * @param options - Optional filters for selective population
- *
- * @example
- * populateStateCacheV2({ engine: lix.engine! });
- */
-export function populateStateCacheV2(args: {
-	engine: Pick<
-		LixEngine,
-		"sqlite" | "executeSync" | "runtimeCacheRef" | "hooks"
-	>;
-	options?: PopulateStateCacheV2Options;
-}): void {
-	const { sqlite } = args.engine;
-	const options = args.options ?? {};
-
-	let versionsToPopulate: string[];
-
-	if (options.version_id) {
-		// When a specific version is requested, also include all its ancestors
-		// This ensures the resolved view can access inherited state
-		// Use the materializer's version ancestry view to find all ancestors
-		const ancestorRows = sqlite.exec({
-			sql: `
-				SELECT DISTINCT ancestor_version_id as version_id
-				FROM lix_internal_materialization_version_ancestry
-				WHERE version_id = ?
-			`,
-			bind: [options.version_id],
-			returnValue: "resultRows",
-			rowMode: "array",
-		}) as [string][];
-
-		// The ancestry view includes the version itself and all its ancestors
-		versionsToPopulate =
-			ancestorRows.length > 0
-				? ancestorRows.map((row) => row[0])
-				: [options.version_id];
-	} else {
-		// If no version_id specified, populate all active versions (with tips)
-		const tipRows = sqlite.exec({
-			sql: `SELECT version_id FROM lix_internal_materialization_version_tips`,
-			returnValue: "resultRows",
-			rowMode: "array",
-		}) as [string][];
-		versionsToPopulate = tipRows.map((row) => row[0]);
-	}
-
-	if (versionsToPopulate.length === 0) {
-		return;
-	}
-
-	// Clear existing cache entries for the versions being populated
-	const existingTables = sqlite.exec({
-		sql: `SELECT name FROM sqlite_schema 
-		      WHERE type='table' 
-		      AND name LIKE 'lix_internal_state_cache_v2_%'`,
-		returnValue: "resultRows",
-	}) as any[];
-
-	const tableCache = getStateCacheV2Tables({ engine: args.engine });
-
-	const placeholders = versionsToPopulate.map(() => "?").join(",");
-	for (const row of existingTables ?? []) {
-		const tableName = row?.[0] as string;
-		if (!tableName) continue;
-
-		const columns = getStateCacheV2Columns({
-			engine: args.engine,
-			tableName,
-		});
-		if (!columns.has("version_id")) {
-			sqlite.exec({ sql: `DROP TABLE ${tableName}` });
-			clearStateCacheV2Columns({ engine: args.engine, tableName });
-			tableCache.delete(tableName);
-			continue;
-		}
-
-		tableCache.add(tableName);
-		sqlite.exec({
-			sql: `DELETE FROM ${tableName} WHERE version_id IN (${placeholders})`,
-			bind: versionsToPopulate,
-		});
-	}
-
-	// Query materialized state to get changes for all required versions
-	const selectPlaceholders = versionsToPopulate.map(() => "?").join(",");
-	const selectSql = `
-		SELECT 
-			m.entity_id,
-			m.schema_key,
-			m.file_id,
-			m.version_id,
-			m.plugin_key,
-			m.snapshot_content,
-			m.schema_version,
-			m.created_at,
-			m.updated_at,
-			m.change_id,
-			m.commit_id,
-			m.inherited_from_version_id
-		FROM lix_internal_state_materializer m
-		WHERE m.version_id IN (${selectPlaceholders})
-		  AND m.inherited_from_version_id IS NULL
-	`;
-
-	const results = sqlite.exec({
-		sql: selectSql,
-		bind: versionsToPopulate,
-		returnValue: "resultRows",
-		rowMode: "object",
-	}) as any[];
-
-	if (!results || results.length === 0) {
-		return;
-	}
-
-	const materializedChanges = results.map((row) => {
-		const changeId =
-			row.change_id ??
-			`${row.schema_key}:${row.entity_id}:${row.version_id}:materializer`;
-		const commitId =
-			row.commit_id ??
-			row.change_id ??
-			`${row.version_id}:${row.entity_id}:materializer`;
-
-		return {
-			id: changeId,
-			entity_id: row.entity_id,
-			schema_key: row.schema_key,
-			schema_version: row.schema_version,
-			file_id: row.file_id,
-			plugin_key: row.plugin_key,
-			snapshot_content: row.snapshot_content,
-			created_at: row.created_at,
-			metadata: null,
-			version_id: row.version_id,
-			commit_id: commitId,
-			lixcol_version_id: row.version_id,
-			lixcol_commit_id: commitId,
-			inherited_from_version_id: row.inherited_from_version_id,
-		} as MaterializedPopulateChange;
-	});
-
-	updateStateCacheV2({
-		engine: {
-			executeSync: args.engine.executeSync,
-			runtimeCacheRef: args.engine.runtimeCacheRef,
-			hooks: args.engine.hooks,
-			sqlite: args.engine.sqlite,
-		},
-		changes: materializedChanges,
-	});
-}
-
-type MaterializedPopulateChange = MaterializedChange & {
-	inherited_from_version_id?: string | null;
-};

package/src/state/cache-v2/schema-metadata.ts

@@ -1,46 +0,0 @@
-export type CacheSchemaPropertyValueKind =
-	| "string"
-	| "number"
-	| "integer"
-	| "boolean"
-	| "json";
-
-export interface CacheSchemaPropertyMetadata {
-	propertyName: string;
-	columnName: string;
-	valueKind: CacheSchemaPropertyValueKind;
-}
-
-const schemaPropertyMetadata = new Map<string, CacheSchemaPropertyMetadata[]>();
-
-function metadataKey(schemaKey: string, schemaVersion: string): string {
-	return `${schemaKey}::${schemaVersion}`;
-}
-
-export function registerStateCacheSchemaProperties(args: {
-	schemaKey: string;
-	schemaVersion: string;
-	properties: CacheSchemaPropertyMetadata[];
-}): void {
-	const key = metadataKey(args.schemaKey, args.schemaVersion);
-	// Store a copy to avoid accidental external mutation
-	schemaPropertyMetadata.set(key, [...args.properties]);
-}
-
-export function getStateCacheSchemaProperties(args: {
-	schemaKey: string;
-	schemaVersion: string;
-}): CacheSchemaPropertyMetadata[] | undefined {
-	const key = metadataKey(args.schemaKey, args.schemaVersion);
-	const properties = schemaPropertyMetadata.get(key);
-	return properties ? [...properties] : undefined;
-}
-
-export function clearStateCacheSchemaProperties(args: {
-	schemaKey: string;
-	schemaVersion: string;
-}): void {
-	schemaPropertyMetadata.delete(
-		metadataKey(args.schemaKey, args.schemaVersion)
-	);
-}

package/src/state/cache-v2/schema.bench.ts

@@ -1,238 +0,0 @@
-import { bench } from "vitest";
-import { openLix } from "../../lix/open-lix.js";
-import { getTimestamp } from "../../engine/functions/timestamp.js";
-import type { LixChangeRaw } from "../../change/schema-definition.js";
-import { updateStateCacheV2 } from "./update-state-cache.js";
-import { LixStoredSchemaSchema } from "../../stored-schema/schema-definition.js";
-import { schemaKeyToCacheTableNameV2 } from "./create-schema-cache-table.js";
-
-const ROW_NUM = 100;
-const BENCH_SCHEMA_KEY = "bench_cache_v2";
-const BENCH_SCHEMA_VERSION = "1.0";
-const BENCH_PLUGIN_KEY = "bench_plugin";
-
-const benchSchemaDefinition = {
-	$schema: "http://json-schema.org/draft-07/schema#",
-	type: "object",
-	additionalProperties: false,
-	properties: {
-		id: { type: "string" },
-		value: { type: "string" },
-		data_index: { type: "integer" },
-		nested: { type: "object" },
-		tag: { type: "string" },
-	},
-	required: ["id", "value", "data_index", "tag"],
-	"x-lix-key": BENCH_SCHEMA_KEY,
-	"x-lix-version": BENCH_SCHEMA_VERSION,
-	"x-lix-primary-key": ["/id"],
-} as const;
-
-async function registerBenchSchema(lix: Awaited<ReturnType<typeof openLix>>) {
-	const timestamp = await getTimestamp({ lix });
-	updateStateCacheV2({
-		engine: adaptEngine(lix),
-		changes: [
-			{
-				id: `schema-${BENCH_SCHEMA_KEY}`,
-				entity_id: `${BENCH_SCHEMA_KEY}~${BENCH_SCHEMA_VERSION}`,
-				schema_key: LixStoredSchemaSchema["x-lix-key"],
-				schema_version: LixStoredSchemaSchema["x-lix-version"],
-				file_id: "lix",
-				plugin_key: "lix_sdk",
-				snapshot_content: JSON.stringify({ value: benchSchemaDefinition }),
-				created_at: timestamp,
-			},
-		],
-		commit_id: "bench-schema",
-		version_id: "global",
-	});
-}
-
-function adaptEngine(lix: Awaited<ReturnType<typeof openLix>>) {
-	const engine = lix.engine!;
-	return {
-		executeSync: engine.executeSync,
-		runtimeCacheRef: engine.runtimeCacheRef,
-		hooks: engine.hooks,
-		sqlite: engine.sqlite,
-	};
-}
-
-function buildChange(
-	index: number,
-	timestamp: string,
-	overrides?: Partial<LixChangeRaw>
-): LixChangeRaw {
-	return {
-		id: `change-${index}`,
-		entity_id: `entity-${index}`,
-		schema_key: BENCH_SCHEMA_KEY,
-		schema_version: BENCH_SCHEMA_VERSION,
-		file_id: "lix",
-		plugin_key: BENCH_PLUGIN_KEY,
-		snapshot_content: JSON.stringify({
-			id: `entity-${index}`,
-			value: `test-value-${index}`,
-			data_index: index,
-			nested: {
-				field1: `field1-${index}`,
-				field2: index * 2,
-				field3: index % 2 === 0,
-			},
-			tag: `tag-${index % 10}`,
-		}),
-		created_at: timestamp,
-		...overrides,
-	};
-}
-
-function buildDeleteChange(index: number, timestamp: string): LixChangeRaw {
-	return {
-		id: `delete-${index}`,
-		entity_id: `entity-${index}`,
-		schema_key: BENCH_SCHEMA_KEY,
-		schema_version: BENCH_SCHEMA_VERSION,
-		file_id: "lix",
-		plugin_key: BENCH_PLUGIN_KEY,
-		snapshot_content: null,
-		created_at: timestamp,
-	};
-}
-
-async function seedCache(
-	lix: Awaited<ReturnType<typeof openLix>>,
-	rowCount: number,
-	timestamp: string
-) {
-	const changes = Array.from({ length: rowCount }, (_, i) =>
-		buildChange(i, timestamp)
-	);
-	updateStateCacheV2({
-		engine: adaptEngine(lix),
-		changes,
-		commit_id: "bench-seed",
-		version_id: "global",
-	});
-}
-
-function clearTable(lix: Awaited<ReturnType<typeof openLix>>) {
-	const tableName = schemaKeyToCacheTableNameV2(
-		BENCH_SCHEMA_KEY,
-		BENCH_SCHEMA_VERSION
-	);
-	lix.engine!.sqlite.exec({ sql: `DELETE FROM ${tableName}` });
-}
-
-bench(`insert ${ROW_NUM} rows into cache`, async () => {
-	const lix = await openLix({});
-	await registerBenchSchema(lix);
-	clearTable(lix);
-	const timestamp = await getTimestamp({ lix });
-	await seedCache(lix, ROW_NUM, timestamp);
-});
-
-bench("query with json_extract from cache", async () => {
-	const lix = await openLix({});
-	await registerBenchSchema(lix);
-	clearTable(lix);
-	const timestamp = await getTimestamp({ lix });
-	await seedCache(lix, ROW_NUM, timestamp);
-
-	const tableName = schemaKeyToCacheTableNameV2(
-		BENCH_SCHEMA_KEY,
-		BENCH_SCHEMA_VERSION
-	);
-	lix.engine!.sqlite.exec({
-		sql: `SELECT value, data_index, json_extract(nested, '$.field3') AS field3
-			FROM ${tableName}
-			WHERE json_extract(nested, '$.field3') = 1`,
-		returnValue: "resultRows",
-	});
-});
-
-bench("query through resolved_state_by_version view", async () => {
-	const lix = await openLix({});
-	await registerBenchSchema(lix);
-	clearTable(lix);
-	const timestamp = await getTimestamp({ lix });
-	await seedCache(lix, ROW_NUM, timestamp);
-
-	lix.engine!.sqlite.exec({
-		sql: `SELECT entity_id, schema_key, json_extract(snapshot_content, '$.value') AS value
-			FROM lix_internal_state_vtable
-			WHERE schema_key = ? AND version_id = 'global'
-			AND json_extract(snapshot_content, '$.nested.field3') = 1`,
-		bind: [BENCH_SCHEMA_KEY],
-		returnValue: "resultRows",
-	});
-});
-
-bench("complex OR query (tag filter)", async () => {
-	const lix = await openLix({});
-	await registerBenchSchema(lix);
-	clearTable(lix);
-	const timestamp = await getTimestamp({ lix });
-	await seedCache(lix, ROW_NUM, timestamp);
-
-	const tableName = schemaKeyToCacheTableNameV2(
-		BENCH_SCHEMA_KEY,
-		BENCH_SCHEMA_VERSION
-	);
-	lix.engine!.sqlite.exec({
-		sql: `SELECT entity_id FROM ${tableName}
-			WHERE tag = 'tag-1' OR tag = 'tag-2'
-			AND is_tombstone = 0`,
-		returnValue: "resultRows",
-	});
-});
-
-bench("update 100 rows in cache", async () => {
-	const lix = await openLix({});
-	await registerBenchSchema(lix);
-	clearTable(lix);
-	const timestamp = await getTimestamp({ lix });
-	await seedCache(lix, ROW_NUM, timestamp);
-
-	const updates = Array.from({ length: 100 }, (_, idx) =>
-		buildChange(idx, timestamp, {
-			snapshot_content: JSON.stringify({
-				id: `entity-${idx}`,
-				value: `updated-value-${idx}`,
-				data_index: idx + 1000,
-				nested: {
-					field1: `updated-${idx}`,
-					field2: (idx + 1000) * 2,
-					field3: idx % 2 !== 0,
-				},
-				tag: `tag-${idx % 10}`,
-			}),
-		})
-	);
-
-	updateStateCacheV2({
-		engine: adaptEngine(lix),
-		changes: updates,
-		commit_id: "bench-update",
-		version_id: "global",
-	});
-});
-
-bench("delete 100 rows from cache", async () => {
-	const lix = await openLix({});
-	await registerBenchSchema(lix);
-	clearTable(lix);
-	const timestamp = await getTimestamp({ lix });
-	await seedCache(lix, ROW_NUM, timestamp);
-
-	const deletes = Array.from({ length: 100 }, (_, idx) =>
-		buildDeleteChange(idx, timestamp)
-	);
-
-	updateStateCacheV2({
-		engine: adaptEngine(lix),
-		changes: deletes,
-		commit_id: "bench-delete",
-		version_id: "global",
-	});
-});