@ontrails/drizzle 1.0.0-beta.15

package/dist/runtime.js

@@ -0,0 +1,755 @@
+import { Database } from 'bun:sqlite';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { AlreadyExistsError, ConflictError, InternalError, Result, ValidationError, resource, } from '@ontrails/core';
+import { versionFieldName } from '@ontrails/store';
+import { bindStoreDefinition } from '@ontrails/store/internal/signal-identity';
+import { and, eq, sql } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/bun-sqlite';
+import { deriveDrizzleTables, deriveFieldSpec, deriveSqliteSchemaStatements, } from './schema.js';
+const defaultResourceId = 'store';
+const connectionClients = new WeakMap();
+const connectionTempDirs = new WeakMap();
+const cloneValue = (value) => structuredClone(value);
+const openSqliteDatabase = (url, readOnly) => {
+    const client = new Database(url, readOnly ? { readonly: true } : { create: true });
+    client.run('PRAGMA foreign_keys = ON');
+    if (!readOnly) {
+        client.run('PRAGMA journal_mode = WAL');
+        client.run('PRAGMA synchronous = NORMAL');
+    }
+    return client;
+};
+const asError = (error) => error instanceof Error ? error : new Error(String(error));
+const storeTableNames = (definition) => definition.tableNames;
+const registerConnection = (connection, client, tempDir) => {
+    connectionClients.set(connection, client);
+    if (tempDir !== undefined) {
+        connectionTempDirs.set(connection, tempDir);
+    }
+    return connection;
+};
+const closeConnection = (connection) => {
+    connectionClients.get(connection)?.close();
+    connectionClients.delete(connection);
+    const tempDir = connectionTempDirs.get(connection);
+    if (tempDir !== undefined) {
+        rmSync(tempDir, { force: true, recursive: true });
+        connectionTempDirs.delete(connection);
+    }
+};
+const createReadonlyMockTempDir = () => mkdtempSync(join(tmpdir(), 'trails-drizzle-readonly-'));
+const mapDatabaseError = (tableName, error) => {
+    if (error instanceof ValidationError ||
+        error instanceof AlreadyExistsError ||
+        error instanceof ConflictError ||
+        error instanceof InternalError) {
+        return error;
+    }
+    // ZodError from .parse() should surface as ValidationError, not InternalError.
+    const resolved = asError(error);
+    if (resolved.name === 'ZodError') {
+        return new ValidationError(`Store table "${tableName}" input failed schema validation: ${resolved.message}`, { cause: resolved });
+    }
+    if (resolved.message.includes('UNIQUE constraint failed')) {
+        return new AlreadyExistsError(`Drizzle store insert for table "${tableName}" violated a uniqueness constraint`, { cause: resolved });
+    }
+    if (resolved.message.includes('FOREIGN KEY constraint failed')) {
+        return new ValidationError(`Drizzle store insert for table "${tableName}" violated a foreign key constraint`, { cause: resolved });
+    }
+    return new InternalError(`Drizzle store encountered an unexpected error for table "${tableName}": ${resolved.message}`, { cause: resolved });
+};
+const formatIssues = (issues) => issues.map((issue) => issue.message).join('; ');
+const parseEntity = (table, value) => {
+    const parsed = table.schema.safeParse(value);
+    if (!parsed.success) {
+        throw new InternalError(`Drizzle store for table "${table.name}" returned an entity that does not match the schema: ${formatIssues(parsed.error.issues)}`);
+    }
+    return parsed.data;
+};
+const normalizeWriteInput = (input) => Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined));
+const baseFieldKind = (table, field) => deriveFieldSpec(field, table.schema.shape[field]).kind;
+const TIMESTAMP_FIELD_NAMES = new Set([
+    'createdAt',
+    'updatedAt',
+    'created_at',
+    'updated_at',
+]);
+const ID_FIELD_SUFFIX_RE = /[Ii]d$/;
+/**
+ * Returns true when the given field on `table` is the framework-managed
+ * version column. Used by insert and upsert paths to gate behavior that
+ * only applies to versioned tables, preventing silent data loss when a
+ * non-versioned table happens to have a user field named `version`.
+ */
+const isVersionManagedField = (table, fieldName) => table.versioned && fieldName === versionFieldName;
+/**
+ * Synthesize a value for a generated field during insert.
+ *
+ * The connector recognizes these conventions for generated fields:
+ *
+ * - **Primary key** (`integer` type): auto-increment, left to SQLite.
+ * - **Timestamp fields** (`createdAt`, `updatedAt`, `created_at`,
+ *   `updated_at`): materialized as `new Date()` (date type) or ISO 8601
+ *   string (text type).
+ * - **ID-like text fields** (name ends with `Id` or `id`): filled with
+ *   `Bun.randomUUIDv7()`.
+ *
+ * Any other generated `text` field that does not match a recognized convention
+ * throws a `ValidationError` — the developer must either supply a value or
+ * give the field a Zod default.
+ *
+ * All other generated field types fall through to `undefined`, letting the
+ * schema's Zod default (if any) apply during validation.
+ */
+const generatedTimestamp = (kind) => kind === 'date' ? new Date() : new Date().toISOString();
+const generatedTextValue = (tableName, fieldName) => {
+    if (ID_FIELD_SUFFIX_RE.test(fieldName)) {
+        return Bun.randomUUIDv7();
+    }
+    throw new ValidationError(`Store table "${tableName}" has a generated text field "${fieldName}" that does not match a recognized convention (timestamp or ID field). Supply a value or add a Zod default.`);
+};
+const generatedVersionValue = (tableName, kind) => {
+    if (kind === 'integer') {
+        return 1;
+    }
+    throw new ValidationError(`Store table "${tableName}" has a versioned "${versionFieldName}" field of type "${kind}", but the framework requires it to be an integer. Ensure the schema uses z.number().int() for the version field.`);
+};
+const generatedFallbackValue = (table, field, fieldName, kind) => {
+    if (field === table.primaryKey && kind === 'integer') {
+        return undefined;
+    }
+    if (TIMESTAMP_FIELD_NAMES.has(fieldName)) {
+        return generatedTimestamp(kind);
+    }
+    if (kind === 'text') {
+        return generatedTextValue(table.name, fieldName);
+    }
+    throw new ValidationError(`Store table "${table.name}" has a generated field "${fieldName}" of unrecognized type "${kind}". Only "integer" (primary key), "text", and timestamp fields are supported as generated fields. Supply a value or add a Zod default.`);
+};
+const generatedValueForInsert = (table, field) => {
+    const fieldName = field;
+    const kind = baseFieldKind(table, field);
+    if (isVersionManagedField(table, fieldName)) {
+        return generatedVersionValue(table.name, kind);
+    }
+    return generatedFallbackValue(table, field, fieldName, kind);
+};
+const materializeGeneratedFields = (table, input) => {
+    const next = { ...input };
+    for (const field of table.generated) {
+        if (next[field] !== undefined) {
+            continue;
+        }
+        const generated = generatedValueForInsert(table, field);
+        if (generated !== undefined) {
+            next[field] = generated;
+        }
+    }
+    return next;
+};
+const validateFixturePayload = (table, input) => {
+    const parsed = table.fixtureSchema.safeParse(input);
+    if (!parsed.success) {
+        throw new ValidationError(`Store table "${table.name}" insert payload is invalid after generated-field materialization: ${formatIssues(parsed.error.issues)}`);
+    }
+    return normalizeWriteInput(parsed.data);
+};
+const applyGeneratedInsertFields = (table, input) => validateFixturePayload(table, materializeGeneratedFields(table, input));
+const applyGeneratedUpdateFields = (table, input) => {
+    const updatedAtKey = ['updatedAt', 'updated_at'].find((key) => table.generated.includes(key));
+    if (!updatedAtKey) {
+        return normalizeWriteInput(input);
+    }
+    const kind = baseFieldKind(table, updatedAtKey);
+    return normalizeWriteInput({
+        ...input,
+        [updatedAtKey]: input[updatedAtKey] ??
+            (kind === 'date' ? new Date() : new Date().toISOString()),
+    });
+};
+const versionFromEntity = (table, entity) => {
+    const version = entity[versionFieldName];
+    if (typeof version === 'number' && Number.isInteger(version) && version > 0) {
+        return version;
+    }
+    throw new InternalError(`Drizzle store for table "${table.name}" returned a versioned entity without a valid integer "${versionFieldName}" field.`);
+};
+const versionConflictError = (tableName, id, expectedVersion, actualVersion) => new ConflictError(actualVersion === null
+    ? `Store table "${tableName}" expected version ${expectedVersion} for "${String(id)}" but found no existing row.`
+    : `Store table "${tableName}" expected version ${expectedVersion} for "${String(id)}" but found ${actualVersion}.`);
+const expectedVersionFromInput = (input) => {
+    const candidate = input[versionFieldName];
+    return typeof candidate === 'number' &&
+        Number.isInteger(candidate) &&
+        candidate > 0
+        ? candidate
+        : undefined;
+};
+const requireUpdateFields = (tableName, input) => {
+    const userFields = normalizeWriteInput(input);
+    if (Object.keys(userFields).length > 0) {
+        return userFields;
+    }
+    throw new ValidationError(`Store table "${tableName}" update requires at least one field to set.`);
+};
+const assertExpectedVersionMatch = (table, id, existing, expectedVersion) => {
+    if (!table.versioned || expectedVersion === undefined) {
+        return;
+    }
+    const currentVersion = versionFromEntity(table, existing);
+    if (currentVersion !== expectedVersion) {
+        throw versionConflictError(table.name, id, expectedVersion, currentVersion);
+    }
+};
+const resolveUpsertWithoutPatch = (table, identifier, input, expectedVersion, readEntity, insertEntity) => {
+    const existing = readEntity(identifier);
+    if (existing === null) {
+        if (expectedVersion !== undefined) {
+            throw versionConflictError(table.name, identifier, expectedVersion, null);
+        }
+        return insertEntity(input);
+    }
+    assertExpectedVersionMatch(table, identifier, existing, expectedVersion);
+    return existing;
+};
+const resolveUpsertAfterMissingUpdate = (table, identifier, input, expectedVersion, insertEntity) => {
+    if (expectedVersion !== undefined) {
+        throw versionConflictError(table.name, identifier, expectedVersion, null);
+    }
+    return insertEntity(input);
+};
+const ensureNotCyclic = (visiting, tableName) => {
+    if (!visiting.has(tableName)) {
+        return;
+    }
+    throw new ValidationError(`Store definition contains a reference cycle involving "${tableName}", which the SQLite connector cannot seed automatically`);
+};
+const pushVisitDependencies = (stack, definition, visited, tableName) => {
+    const table = definition.tables[tableName];
+    if (table === undefined) {
+        return;
+    }
+    for (const target of Object.values(table.references).toReversed()) {
+        if (target !== undefined && !visited.has(target)) {
+            stack.push({ expanded: false, tableName: target });
+        }
+    }
+};
+const finishVisitFrame = (frame, visiting, visited, ordered) => {
+    visiting.delete(frame.tableName);
+    visited.add(frame.tableName);
+    ordered.push(frame.tableName);
+};
+const startVisitFrame = (stack, definition, visiting, visited, tableName) => {
+    ensureNotCyclic(visiting, tableName);
+    visiting.add(tableName);
+    stack.push({ expanded: true, tableName });
+    pushVisitDependencies(stack, definition, visited, tableName);
+};
+const visitTableForSeeding = (definition, visiting, visited, ordered, tableName) => {
+    const stack = [{ expanded: false, tableName }];
+    while (stack.length > 0) {
+        const frame = stack.pop();
+        if (frame === undefined) {
+            continue;
+        }
+        if (frame.expanded) {
+            finishVisitFrame(frame, visiting, visited, ordered);
+            continue;
+        }
+        if (!visited.has(frame.tableName)) {
+            startVisitFrame(stack, definition, visiting, visited, frame.tableName);
+        }
+    }
+};
+const topologicalTableOrder = (definition) => {
+    const visited = new Set();
+    const visiting = new Set();
+    const ordered = [];
+    for (const tableName of definition.tableNames) {
+        visitTableForSeeding(definition, visiting, visited, ordered, tableName);
+    }
+    return Object.freeze(ordered);
+};
+const ensureSqliteSchema = (client, definition) => {
+    for (const statement of deriveSqliteSchemaStatements(definition)) {
+        client.run(statement);
+    }
+};
+const primaryKeyColumn = (table, field) => table[field];
+const buildFilterConditions = (drizzleTable, filters) => filters === undefined
+    ? []
+    : Object.entries(filters)
+        .filter(([, value]) => value !== undefined)
+        .map(([field, value]) => eq(primaryKeyColumn(drizzleTable, field), value));
+const createReadOnlyAccessor = (definitionTable, drizzleTable, db) => ({
+    get(id) {
+        try {
+            const row = db
+                .select()
+                .from(drizzleTable)
+                .where(eq(primaryKeyColumn(drizzleTable, definitionTable.primaryKey), id))
+                .get();
+            return Promise.resolve(row === null || row === undefined
+                ? null
+                : cloneValue(parseEntity(definitionTable, row)));
+        }
+        catch (error) {
+            return Promise.reject(mapDatabaseError(definitionTable.name, error));
+        }
+    },
+    list(filters, options) {
+        try {
+            const conditions = buildFilterConditions(drizzleTable, filters);
+            const base = db.select().from(drizzleTable).$dynamic();
+            const filtered = conditions.length > 0 ? base.where(and(...conditions)) : base;
+            const rows = filtered
+                .limit(options?.limit ?? -1)
+                .offset(options?.offset ?? 0)
+                .all();
+            return Promise.resolve(rows.map((row) => cloneValue(parseEntity(definitionTable, row))));
+        }
+        catch (error) {
+            return Promise.reject(mapDatabaseError(definitionTable.name, error));
+        }
+    },
+});
+const createWritableAccessor = (definitionTable, drizzleTable, db) => {
+    const findRowById = (id) => db
+        .select()
+        .from(drizzleTable)
+        .where(eq(primaryKeyColumn(drizzleTable, definitionTable.primaryKey), id))
+        .get();
+    const readEntity = (id) => {
+        const existing = findRowById(id);
+        return existing === undefined
+            ? null
+            : cloneValue(parseEntity(definitionTable, existing));
+    };
+    const insertEntity = (input) => {
+        const row = db
+            .insert(drizzleTable)
+            .values(applyGeneratedInsertFields(definitionTable, input))
+            .returning()
+            .get();
+        return cloneValue(parseEntity(definitionTable, row));
+    };
+    const versionColumn = definitionTable.versioned
+        ? primaryKeyColumn(drizzleTable, versionFieldName)
+        : undefined;
+    // oxlint-disable-next-line max-statements -- atomic UPDATE ... WHERE with version guard and conflict diagnosis reads more clearly as one function
+    const updateEntity = (id, input, expectedVersion) => {
+        const base = applyGeneratedUpdateFields(definitionTable, requireUpdateFields(definitionTable.name, input));
+        // Atomic increment via SQL expression — avoids the read-then-write race
+        // on optimistic-concurrency updates.
+        const fields = definitionTable.versioned && versionColumn !== undefined
+            ? { ...base, [versionFieldName]: sql `${versionColumn} + 1` }
+            : base;
+        const idColumn = primaryKeyColumn(drizzleTable, definitionTable.primaryKey);
+        const idCondition = eq(idColumn, id);
+        const condition = definitionTable.versioned &&
+            versionColumn !== undefined &&
+            expectedVersion !== undefined
+            ? and(idCondition, eq(versionColumn, expectedVersion))
+            : idCondition;
+        const row = db
+            .update(drizzleTable)
+            .set(fields)
+            .where(condition)
+            .returning()
+            .get();
+        if (row !== undefined) {
+            return cloneValue(parseEntity(definitionTable, row));
+        }
+        if (!definitionTable.versioned ||
+            versionColumn === undefined ||
+            expectedVersion === undefined) {
+            return null;
+        }
+        const existing = readEntity(id);
+        throw versionConflictError(definitionTable.name, id, expectedVersion, existing === null ? null : versionFromEntity(definitionTable, existing));
+    };
+    const patchFromUpsert = (input) => Object.fromEntries(Object.entries(input).filter(([field, value]) => field !== definitionTable.identity &&
+        !isVersionManagedField(definitionTable, field) &&
+        value !== undefined));
+    const upsertEntity = (input) => {
+        const identifier = input[definitionTable.identity];
+        const expectedVersion = definitionTable.versioned
+            ? expectedVersionFromInput(input)
+            : undefined;
+        if (identifier === undefined) {
+            if (expectedVersion !== undefined) {
+                throw new ValidationError(`Store table "${definitionTable.name}" cannot accept an expected version without an identity during upsert.`);
+            }
+            return insertEntity(input);
+        }
+        const patch = patchFromUpsert(input);
+        if (Object.keys(patch).length === 0) {
+            return resolveUpsertWithoutPatch(definitionTable, identifier, input, expectedVersion, readEntity, insertEntity);
+        }
+        return (updateEntity(identifier, patch, expectedVersion) ??
+            resolveUpsertAfterMissingUpdate(definitionTable, identifier, input, expectedVersion, insertEntity));
+    };
+    return {
+        ...createReadOnlyAccessor(definitionTable, drizzleTable, db),
+        insert(input) {
+            try {
+                const parsed = definitionTable.insertSchema.parse(input);
+                return Promise.resolve(insertEntity(parsed));
+            }
+            catch (error) {
+                return Promise.reject(mapDatabaseError(definitionTable.name, error));
+            }
+        },
+        remove(id) {
+            try {
+                const deleted = db
+                    .delete(drizzleTable)
+                    .where(eq(primaryKeyColumn(drizzleTable, definitionTable.primaryKey), id))
+                    .returning({
+                    deletedId: primaryKeyColumn(drizzleTable, definitionTable.primaryKey),
+                })
+                    .get();
+                return Promise.resolve({ deleted: deleted !== undefined });
+            }
+            catch (error) {
+                return Promise.reject(mapDatabaseError(definitionTable.name, error));
+            }
+        },
+        update(id, input) {
+            try {
+                const parsed = definitionTable.updateSchema.parse(input);
+                return Promise.resolve(updateEntity(id, parsed));
+            }
+            catch (error) {
+                return Promise.reject(mapDatabaseError(definitionTable.name, error));
+            }
+        },
+        upsert(input) {
+            try {
+                const parsed = definitionTable.fixtureSchema.parse(input);
+                const normalized = normalizeWriteInput(parsed);
+                return Promise.resolve(upsertEntity(normalized));
+            }
+            catch (error) {
+                return Promise.reject(mapDatabaseError(definitionTable.name, error));
+            }
+        },
+    };
+};
+/** Collect non-empty fixture arrays keyed by table name. */
+const collectFixtures = (definition, seed) => {
+    const result = new Map();
+    for (const tableName of definition.tableNames) {
+        const table = definition.tables[tableName];
+        if (table === undefined) {
+            continue;
+        }
+        const fixtures = seed?.[tableName] ?? table.fixtures;
+        if (fixtures.length > 0) {
+            result.set(tableName, fixtures);
+        }
+    }
+    return result;
+};
+/** Insert fixture rows in topological order. */
+const insertFixtureRows = (definition, tables, db, fixturesByTable) => {
+    for (const tableName of topologicalTableOrder(definition)) {
+        const defTable = definition.tables[tableName];
+        const drizzleTable = tables[tableName];
+        const fixtures = fixturesByTable.get(tableName);
+        if (!defTable || !drizzleTable || !fixtures) {
+            continue;
+        }
+        for (const fixture of fixtures) {
+            db.insert(drizzleTable)
+                .values(applyGeneratedInsertFields(defTable, fixture))
+                .run();
+        }
+    }
+};
+const seedFixtures = (definition, tables, db, seed) => {
+    const fixturesByTable = collectFixtures(definition, seed);
+    if (fixturesByTable.size === 0) {
+        return;
+    }
+    insertFixtureRows(definition, tables, db, fixturesByTable);
+};
+const createReadOnlyConnection = (definition, tables, db, client, tempDir) => {
+    const connection = {
+        async query(run) {
+            return await run({ drizzle: db, tables });
+        },
+    };
+    for (const tableName of storeTableNames(definition)) {
+        const definitionTable = definition.tables[tableName];
+        const drizzleTable = tables[tableName];
+        if (definitionTable === undefined || drizzleTable === undefined) {
+            continue;
+        }
+        Object.defineProperty(connection, tableName, {
+            enumerable: true,
+            value: createReadOnlyAccessor(definitionTable, drizzleTable, db),
+        });
+    }
+    return Object.freeze(registerConnection(connection, client, tempDir));
+};
+const createWritableConnection = (definition, tables, db, client) => {
+    const connection = {
+        async query(run) {
+            return await run({ drizzle: db, tables });
+        },
+    };
+    for (const tableName of storeTableNames(definition)) {
+        const definitionTable = definition.tables[tableName];
+        const drizzleTable = tables[tableName];
+        if (definitionTable === undefined || drizzleTable === undefined) {
+            continue;
+        }
+        Object.defineProperty(connection, tableName, {
+            enumerable: true,
+            value: createWritableAccessor(definitionTable, drizzleTable, db),
+        });
+    }
+    return Object.freeze(registerConnection(connection, client));
+};
+const seedReadonlyMockDatabase = (definition, tables, url, seed) => {
+    const writableClient = openSqliteDatabase(url, false);
+    try {
+        ensureSqliteSchema(writableClient, definition);
+        const writableDb = drizzle({ client: writableClient, schema: tables });
+        seedFixtures(definition, tables, writableDb, seed);
+    }
+    finally {
+        writableClient.close();
+    }
+};
+const openReadonlyMockConnection = (definition, tables, url, tempDir) => {
+    const client = openSqliteDatabase(url, true);
+    try {
+        const db = drizzle({ client, schema: tables });
+        return createReadOnlyConnection(definition, tables, db, client, tempDir);
+    }
+    catch (error) {
+        client.close();
+        throw error;
+    }
+};
+const createReadonlyMockConnection = (definition, tables, seed) => {
+    const tempDir = createReadonlyMockTempDir();
+    const url = join(tempDir, 'mock.sqlite');
+    try {
+        seedReadonlyMockDatabase(definition, tables, url, seed);
+        return openReadonlyMockConnection(definition, tables, url, tempDir);
+    }
+    catch (error) {
+        rmSync(tempDir, { force: true, recursive: true });
+        throw error;
+    }
+};
+/**
+ * Best-effort signal emission after a successful DB write.
+ *
+ * Signal errors are caught and logged rather than re-thrown so that a
+ * listener failure does not mask a successful database mutation. The
+ * caller already holds the write result; surfacing a signal error here
+ * would discard it and confuse error handling upstream.
+ */
+const fireDerivedSignal = async (fire, signalId, entity) => {
+    try {
+        const fired = await fire(signalId, entity);
+        if (fired.isErr()) {
+            console.warn(`[drizzle] signal "${signalId}" emission failed:`, fired.error);
+        }
+    }
+    catch (error) {
+        console.warn(`[drizzle] signal "${signalId}" emission threw:`, error);
+    }
+};
+const inputIdentity = (table, input) => input[table.identity];
+const changedEntity = (previous, next) => previous !== null && next !== null && !Bun.deepEquals(previous, next);
+const bindWritableAccessorSignals = (table, accessor, fire) => Object.freeze({
+    ...accessor,
+    async insert(input) {
+        const created = await accessor.insert(input);
+        await fireDerivedSignal(fire, table.signals.created.id, created);
+        return created;
+    },
+    async remove(id) {
+        // Snapshot taken before delete. May be stale under concurrent writes
+        // since StoreAccessor.remove returns `{ deleted: boolean }` without a
+        // post-delete returning clause. Acceptable for signal consumers that
+        // tolerate eventual consistency; revisit if strict ordering is needed.
+        const existing = await accessor.get(id);
+        const removed = await accessor.remove(id);
+        if (removed.deleted && existing !== null) {
+            await fireDerivedSignal(fire, table.signals.removed.id, existing);
+        }
+        return removed;
+    },
+    async update(id, input) {
+        if (table.versioned) {
+            // Versioned tables auto-increment the version column on every write,
+            // so changedEntity always detects a diff. Skip the redundant pre-read
+            // and fire unconditionally on successful update.
+            const updated = await accessor.update(id, input);
+            if (updated !== null) {
+                await fireDerivedSignal(fire, table.signals.updated.id, updated);
+            }
+            return updated;
+        }
+        const existing = await accessor.get(id);
+        const updated = await accessor.update(id, input);
+        if (changedEntity(existing, updated)) {
+            await fireDerivedSignal(fire, table.signals.updated.id, updated);
+        }
+        return updated;
+    },
+    async upsert(input) {
+        const existingId = inputIdentity(table, input);
+        // NOTE: pre-read is not transactional with the write below. Under
+        // concurrent deletes, `existing` may be non-null while `accessor.upsert`
+        // actually inserts. `created` vs `updated` signal discrimination is
+        // best-effort — matches the same caveat documented on `remove`.
+        const existing = existingId === undefined ? null : await accessor.get(existingId);
+        const written = await accessor.upsert(input);
+        if (existing === null) {
+            await fireDerivedSignal(fire, table.signals.created.id, written);
+            return written;
+        }
+        if (changedEntity(existing, written)) {
+            await fireDerivedSignal(fire, table.signals.updated.id, written);
+        }
+        return written;
+    },
+});
+const bindWritableConnectionSignals = (definition, connection, fire) => {
+    const bound = {
+        query: connection.query,
+    };
+    for (const tableName of storeTableNames(definition)) {
+        const table = definition.tables[tableName];
+        const accessor = connection[tableName];
+        if (table === undefined || accessor === undefined) {
+            continue;
+        }
+        Object.defineProperty(bound, tableName, {
+            enumerable: true,
+            value: bindWritableAccessorSignals(table, accessor, fire),
+        });
+    }
+    return Object.freeze(bound);
+};
+const bindResourceConnection = (access, definition, connection, fire) => {
+    if (access !== 'readwrite' || fire === undefined) {
+        return connection;
+    }
+    return bindWritableConnectionSignals(definition, connection, fire);
+};
+const buildResourceShape = (value, store, tables, access) => Object.freeze({
+    ...value,
+    access,
+    from(ctx) {
+        return bindResourceConnection(access, store, value.from(ctx), ctx.fire);
+    },
+    ...(access === 'readwrite' ? { signals: store.signals } : {}),
+    store,
+    tables,
+});
+const connectionHealth = (connection) => {
+    const client = connectionClients.get(connection);
+    if (client === undefined) {
+        return Result.err(new InternalError('Drizzle store connection is missing its SQLite client'));
+    }
+    try {
+        client.query('SELECT 1').get();
+        return Result.ok({ ok: true });
+    }
+    catch (error) {
+        return Result.err(asError(error));
+    }
+};
+/**
+ * Bind a store definition to a Drizzle-backed SQLite resource.
+ *
+ * The returned resource manages its own connection lifecycle. The `mock()`
+ * factory creates an in-memory SQLite database seeded with fixtures — callers
+ * who obtain a mock connection are responsible for calling `closeConnection()`
+ * when done, or letting the connection be garbage-collected (the underlying
+ * `Database` client is tracked via `WeakMap`).
+ *
+ * Note: the `search` field on `StoreTableInput` is not yet interpreted by
+ * this connector — it is reserved for future full-text search support.
+ */
+export const connectDrizzle = (definition, options) => {
+    const scope = options.id ?? defaultResourceId;
+    const store = bindStoreDefinition(definition, scope);
+    const tables = deriveDrizzleTables(store);
+    return buildResourceShape(resource(scope, {
+        create: () => {
+            try {
+                const client = openSqliteDatabase(options.url, false);
+                try {
+                    ensureSqliteSchema(client, store);
+                }
+                catch (error) {
+                    client.close();
+                    throw error;
+                }
+                const db = drizzle({ client, schema: tables });
+                return Result.ok(createWritableConnection(store, tables, db, client));
+            }
+            catch (error) {
+                return Result.err(new InternalError(`Drizzle store failed to open database at "${options.url}": ${asError(error).message}`, { cause: asError(error) }));
+            }
+        },
+        description: options.description ??
+            'Drizzle-backed writable store bound from an @ontrails/store definition.',
+        dispose: (connection) => {
+            closeConnection(connection);
+        },
+        health: connectionHealth,
+        meta: options.meta,
+        mock: () => {
+            const client = openSqliteDatabase(':memory:', false);
+            try {
+                ensureSqliteSchema(client, store);
+                const db = drizzle({ client, schema: tables });
+                seedFixtures(store, tables, db, options.mockSeed);
+                return createWritableConnection(store, tables, db, client);
+            }
+            catch (error) {
+                client.close();
+                throw error;
+            }
+        },
+    }), store, tables, 'readwrite');
+};
+export const connectReadOnlyDrizzle = (definition, options) => {
+    const scope = options.id ?? defaultResourceId;
+    const store = bindStoreDefinition(definition, scope);
+    const tables = deriveDrizzleTables(store);
+    return buildResourceShape(resource(scope, {
+        create: () => {
+            try {
+                const client = openSqliteDatabase(options.url, true);
+                const db = drizzle({ client, schema: tables });
+                return Result.ok(createReadOnlyConnection(store, tables, db, client));
+            }
+            catch (error) {
+                return Result.err(new InternalError(`Drizzle read-only store failed to open database at "${options.url}": ${asError(error).message}`, { cause: asError(error) }));
+            }
+        },
+        description: options.description ??
+            'Drizzle-backed read-only store bound from an @ontrails/store definition.',
+        dispose: (connection) => {
+            closeConnection(connection);
+        },
+        health: connectionHealth,
+        meta: options.meta,
+        mock: () => createReadonlyMockConnection(store, tables, options.mockSeed),
+    }), store, tables, 'readonly');
+};
+//# sourceMappingURL=runtime.js.map