@vibesdotdev/storage 0.0.2 → 1.0.0-rc.4

package/dist/adapters/drizzle/drizzle.adapter.impl.js

@@ -0,0 +1,1163 @@
+import { CapabilityError, CaughtFailureSchema, createRuntimeImplementation, settle, valueFreeFailure } from '@vibesdotdev/kernel';
+import { and, Column, asc, count as countRows, desc, eq, getTableColumns, getTableName, gt, gte, ilike, inArray, isNotNull, isNull, is, like, lt, lte, ne, notInArray, sql, Table } from 'drizzle-orm';
+import * as z from 'zod/v4';
+import { applySetAdditions, assertArrayField, assertArrayMembers, unsupportedArrayOperation, updatePatch } from "../../record/array-fields.js";
+import { RecordFilterOperatorSchema } from "../../schemas/record/query-values.js";
+import { RECORD_REVISION_COLUMN, RecordRevisionMetadataSchema, RecordRevisionQuerySchema } from "../../schemas/record/revision.js";
+import { OptimisticLockError } from "../../record/base.js";
+import { loadRecordRelations } from "../../record/relations.js";
+import { resolveStorageTransform } from '@vibesdotdev/storage/transform';
+import { DrizzleAdapterConfigSchema, DrizzleDialectSchema } from "./contracts.js";
+import { SQLITE_DIALECTS, recordTable } from "./record-table.js";
+import { assertRecordRevisionSchema, recordColumns, timestampColumn, softDeleteColumn, ZodNodeSchema } from "../../record/columns.js";
+import { readStoredLayer, validateForPersist } from "../validate-for-persist.js";
+import { parseAdapterInput } from "../parse-adapter-input.js";
+import { getLogger } from '@vibesdotdev/logging';
+/** A row of a host table, or a record on its way to one: column keys to values. */
+const RowSchema = z.record(z.string(), z.unknown());
+const RowsSchema = z.array(RowSchema);
+/** What `select({ count: count() })` answers. */
+const CountRowsSchema = z.array(z.object({ count: z.coerce.number() }));
+const HostDatabaseSchema = z.object({
+    select: z.instanceof(Function),
+    insert: z.instanceof(Function),
+    update: z.instanceof(Function),
+    delete: z.instanceof(Function),
+    transaction: z.instanceof(Function),
+    _: z.object({
+        fullSchema: z.record(z.string(), z.unknown()),
+        tableNamesMap: z.record(z.string(), z.string())
+    })
+});
+/** Whether the host handed a Drizzle database: its query builders and its schema map are present. */
+function isHostDatabase(database) {
+    return HostDatabaseSchema.safeParse(database).success;
+}
+function isText(value) {
+    return typeof value === 'string';
+}
+/** Whether a filter value is an operator map (`{ gt: 1 }`) rather than a scalar, array or Date to match. */
+function isComparison(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value) && !(value instanceof Date);
+}
+/** The owner's Drizzle database, refused typed when the host hands anything else. */
+function hostDatabase(host) {
+    const database = host.getDatabase();
+    if (!isHostDatabase(database)) {
+        throw new CapabilityError('The storage/drizzle-db host did not return a Drizzle database.', 'UNAVAILABLE', {
+            reason: 'storage-drizzle-database-invalid',
+            retryable: false
+        });
+    }
+    return database;
+}
+/** The host schema's table of that name (by schema key or SQL name), if the host declares one. */
+function hostTable(database, tableName) {
+    const schema = database._.fullSchema;
+    const direct = schema[tableName];
+    if (is(direct, Table))
+        return direct;
+    for (const [schemaKey, entry] of Object.entries(schema)) {
+        if (!is(entry, Table))
+            continue;
+        if (database._.tableNamesMap[schemaKey] === tableName || getTableName(entry) === tableName)
+            return entry;
+    }
+    return undefined;
+}
+function resolveTable(database, tableName) {
+    const table = hostTable(database, tableName);
+    if (table)
+        return table;
+    throw new CapabilityError('storage.drizzle could not resolve the table from the host database schema.', 'UNAVAILABLE', {
+        reason: 'storage-drizzle-table-unresolved',
+        retryable: false,
+        details: { tableName }
+    });
+}
+/** The table's own column for a field key, never an inherited property. */
+function columnOf(table, field) {
+    const columns = getTableColumns(table);
+    return Object.hasOwn(columns, field) ? columns[field] : undefined;
+}
+function unconfigured() {
+    return new CapabilityError('storage.drizzle must be configured before use.', 'UNAVAILABLE', {
+        reason: 'storage-drizzle-unconfigured',
+        retryable: false
+    });
+}
+/** The manifest fields a document store reads; the rest of the manifest is not the adapter's. */
+const DocumentManifestSchema = z.object({
+    id: z.string().optional(),
+    idField: z.string().optional(),
+    collectionField: z.string().optional(),
+    adapterConfig: z.record(z.string(), z.unknown()).optional()
+});
+/** The adapter keys a manifest's `adapterConfig` entry may set for a document store. */
+const DocumentAdapterHintsSchema = z.object({
+    tableName: z.string().optional(),
+    transform: z.union([z.string(), z.object({ from: z.string().optional(), to: z.string().optional() })]).optional()
+});
+const manifestInvalid = {
+    message: 'storage.drizzle cannot read the manifest it was handed.',
+    code: 'INVALID_INPUT',
+    reason: 'storage-drizzle-manifest-invalid'
+};
+const CollectionHolderSchema = z.record(z.string(), z.unknown());
+/** The items of a manifest document: its array (or object values), read under the collection field when it has one. */
+function collectionItems(document, collectionField) {
+    const holder = collectionField === undefined ? undefined : CollectionHolderSchema.safeParse(document);
+    const collection = collectionField === undefined ? document : holder?.success ? holder.data[collectionField] : undefined;
+    if (Array.isArray(collection))
+        return collection;
+    const entries = CollectionHolderSchema.safeParse(collection);
+    return entries.success ? Object.values(entries.data) : [];
+}
+const DEFAULT_DRIZZLE_CAPABILITIES = {
+    protocols: ['document', 'record'],
+    capabilities: ['read', 'write'],
+    requiresPairSchema: false,
+    supportsTransactions: true,
+    supportsTTL: false,
+    supportsFTS: false,
+    persistent: true,
+    supportsSubscription: false,
+    supportsHierarchy: false,
+    supportsComputedFields: true,
+    supportsSideEffects: true,
+    supportsRawQueries: false,
+    supportsConditionalWrites: true
+};
+class DrizzleStorageAdapter {
+    databaseHost;
+    runtime;
+    _id = 'storage.drizzle.libsql';
+    _config = null;
+    capabilities;
+    constructor(databaseHost, runtime, capabilities) {
+        this.databaseHost = databaseHost;
+        this.runtime = runtime;
+        this.capabilities = {
+            ...DEFAULT_DRIZZLE_CAPABILITIES,
+            ...capabilities,
+            protocols: capabilities?.protocols
+                ? [...capabilities.protocols]
+                : [...DEFAULT_DRIZZLE_CAPABILITIES.protocols],
+            capabilities: capabilities?.capabilities
+                ? [...capabilities.capabilities]
+                : [...(DEFAULT_DRIZZLE_CAPABILITIES.capabilities ?? [])]
+        };
+    }
+    get id() {
+        return this._id;
+    }
+    setId(id) {
+        this._id = id;
+        return this;
+    }
+    configure(config) {
+        this._config = parseAdapterInput(DrizzleAdapterConfigSchema, config, { message: 'The Drizzle configuration is invalid.', code: 'INVALID_INPUT', reason: 'storage-drizzle-config-invalid' });
+    }
+    isConfigured() {
+        return this._config !== null;
+    }
+    documentStore(namespace, schema, manifestValue) {
+        if (!this._config)
+            throw unconfigured();
+        const configured = this._config;
+        const manifest = parseAdapterInput(DocumentManifestSchema.optional(), manifestValue, manifestInvalid);
+        const hints = parseAdapterInput(DocumentAdapterHintsSchema, manifest?.adapterConfig?.[this.id] ?? manifest?.adapterConfig?.['storage.drizzle'] ?? {}, manifestInvalid);
+        const tableName = hints.tableName ?? configured.tableName ?? namespace;
+        const idField = manifest?.idField ?? 'id';
+        const collectionField = manifest?.collectionField;
+        const transformReference = hints.transform ?? configured.transform;
+        const transformId = transformReference === undefined
+            ? manifest?.id
+            : isText(transformReference)
+                ? transformReference
+                : (transformReference.from ?? manifest?.id);
+        const databaseHost = this.databaseHost;
+        const runtime = this.runtime;
+        async function context() {
+            const database = hostDatabase(databaseHost);
+            const table = resolveTable(database, tableName);
+            const transform = transformId ? await resolveStorageTransform(runtime, transformId) : null;
+            return { database, table, transform };
+        }
+        /** The stored rows as one document, before any schema default is applied. */
+        async function readStored() {
+            const { database, table, transform } = await context();
+            const rows = RowsSchema.parse(await database.select().from(table));
+            if (rows.length === 0)
+                return null;
+            const values = rows.map((row) => transform
+                ? parseAdapterInput(RowSchema, transform.fromRow(row), {
+                    message: 'The storage transform did not map a row to a record.',
+                    code: 'INTERNAL',
+                    reason: 'storage-drizzle-transform-output-invalid',
+                    details: { namespace, transformId: transformId ?? null }
+                })
+                : row);
+            return collectionField ? { [collectionField]: values } : values;
+        }
+        async function load() {
+            const document = await readStored();
+            return document === null ? null : schema.parse(document);
+        }
+        async function loadStored() {
+            const document = await readStored();
+            return document === null ? null : readStoredLayer(schema, document);
+        }
+        async function save(data) {
+            // Persist the caller's validated input, never the parse output (defaults are read-time only).
+            const validated = validateForPersist(schema, data);
+            const { database, table, transform } = await context();
+            const idColumn = columnOf(table, idField);
+            if (!idColumn) {
+                throw new CapabilityError('storage.drizzle cannot reconcile a document whose table has no id column.', 'INVALID_INPUT', {
+                    reason: 'storage-drizzle-id-column-missing',
+                    retryable: false,
+                    details: { tableName, idField }
+                });
+            }
+            const rows = collectionItems(validated, collectionField).map((value) => {
+                const item = parseAdapterInput(RowSchema, value, {
+                    message: 'storage.drizzle documents hold records only.',
+                    code: 'INVALID_INPUT',
+                    reason: 'storage-drizzle-document-item-invalid',
+                    details: { namespace }
+                });
+                return transform?.toRow ? transform.toRow(item) : item;
+            });
+            // Every item is read before the first destructive statement: a bad item leaves the table as it was.
+            const ids = rows.map((row) => row[idField]);
+            const stringIds = ids.filter(isText);
+            if (stringIds.length !== ids.length) {
+                throw new CapabilityError('storage.drizzle document items need a string id.', 'INVALID_INPUT', {
+                    reason: 'storage-drizzle-document-item-id-invalid',
+                    retryable: false,
+                    details: { namespace, idField }
+                });
+            }
+            if (stringIds.length === 0)
+                await database.delete(table);
+            else
+                await database.delete(table).where(notInArray(idColumn, stringIds));
+            for (const row of rows) {
+                const set = Object.fromEntries(Object.entries(row).filter(([key]) => key !== idField));
+                await database.insert(table).values(row).onConflictDoUpdate({ target: idColumn, set });
+            }
+        }
+        return {
+            load,
+            loadStored,
+            save,
+            async update(transform) {
+                // Persist the transform's validated result; hand the caller the parsed value.
+                const next = validateForPersist(schema, await transform(await load()));
+                await save(next);
+                return schema.parse(next);
+            },
+            async exists() {
+                const { database, table } = await context();
+                const result = CountRowsSchema.parse(await database.select({ count: countRows() }).from(table));
+                return (result[0]?.count ?? 0) > 0;
+            },
+            async delete() {
+                const { database, table } = await context();
+                await database.delete(table);
+            },
+            getPath: () => `drizzle://${tableName}`
+        };
+    }
+    keyValueStore(namespace, _keySchema, _valueSchema) {
+        if (!this._config)
+            throw unconfigured();
+        throw new CapabilityError('storage.drizzle has no key-value store. Use app-owned Drizzle tables or the json/localdb adapters for key-value storage.', 'UNAVAILABLE', { reason: 'storage-drizzle-key-value-unsupported', retryable: false, details: { namespace } });
+    }
+    repository(_tableName, _schema, _options) {
+        throw new CapabilityError('storage.drizzle has no repository. Use @vibesdotdev/storage/adapters/drizzle/libsql for direct Drizzle connections and composeDrizzleSchemaExtensions() for schema composition.', 'UNAVAILABLE', { reason: 'storage-drizzle-repository-unsupported', retryable: false });
+    }
+    record(descriptor) {
+        const hostDialect = this.databaseHost.dialect;
+        const parsed = DrizzleDialectSchema.optional().safeParse(hostDialect === undefined ? this._config?.dialect : hostDialect);
+        if (!parsed.success) {
+            throw new CapabilityError('storage.drizzle requires a valid explicit SQL dialect declaration.', 'INVALID_INPUT', {
+                reason: 'storage-drizzle-dialect-invalid', retryable: false
+            });
+        }
+        return new DrizzleStorageRecord(this.id, this.databaseHost, descriptor, this.runtime, parsed.data, this.capabilities.supportsTransactions, this.capabilities.supportsConditionalWrites ?? true);
+    }
+    async ensureReady() {
+        if (!this._config)
+            throw unconfigured();
+    }
+    /** The host's database; a host that cannot hand one is refused typed (the interface's "throws if not initialized"). */
+    getDatabaseConnection() {
+        try {
+            return this.databaseHost.getDatabase();
+        }
+        catch (error) {
+            throw new CapabilityError('The storage/drizzle-db host has no database to hand.', 'UNAVAILABLE', {
+                reason: 'storage-drizzle-database-unavailable',
+                retryable: false,
+                cause: error
+            });
+        }
+    }
+    async initialize() {
+        if (!this._config)
+            throw unconfigured();
+    }
+    async close() { }
+    async healthCheck() {
+        return {
+            healthy: true,
+            details: {
+                note: 'storage.drizzle resolves app-owned tables through the runtime-local storage/drizzle-db host context.'
+            }
+        };
+    }
+}
+function createDrizzleAdapter(id, databaseHost, runtime, capabilities) {
+    const adapter = new DrizzleStorageAdapter(databaseHost, runtime, capabilities);
+    adapter.setId(id);
+    return createRuntimeImplementation({
+        id,
+        kind: 'storage/adapter',
+        implementation: adapter
+    });
+}
+export { createDrizzleAdapter };
+/** Filters a record reads: field names to a value to match or an operator map. */
+const FilterSchema = z.record(z.string(), z.unknown());
+/** The query options `list` reads. */
+const ListOptionsSchema = z.object({
+    where: z.unknown().optional(),
+    orderBy: z
+        .union([
+        z.array(z.object({ field: z.string(), direction: z.enum(['asc', 'desc']) })),
+        z.record(z.string(), z.enum(['asc', 'desc']).optional())
+    ])
+        .optional(),
+    limit: z.number().int().nonnegative().optional(),
+    offset: z.number().int().nonnegative().optional()
+});
+const RANGE_OPERATORS = ['eq', 'ne', 'gt', 'gte', 'lt', 'lte', 'in', 'notIn', 'between'];
+const TEXT_OPERATORS = ['like', 'ilike', 'contains', 'startsWith', 'endsWith'];
+/** The object field schemas of a record schema, unwrapping outer refinements or pipes. */
+function schemaFieldsOf(schema) {
+    let current = schema;
+    for (let depth = 0; depth < 8 && current; depth++) {
+        const parsed = ZodNodeSchema.safeParse(current._zod);
+        if (!parsed.success)
+            break;
+        if (parsed.data.def.type === 'object' && parsed.data.def.shape) {
+            return parsed.data.def.shape;
+        }
+        current = parsed.data.def.innerType ?? parsed.data.def.in;
+    }
+    return {};
+}
+class DrizzleStorageRecord {
+    adapterId;
+    databaseHost;
+    descriptor;
+    runtime;
+    dialect;
+    supportsTransactions;
+    tableName;
+    primaryKey;
+    schema;
+    relations;
+    supportsConditionalWrites;
+    get revisions() {
+        if (!this.descriptor.versioning)
+            return undefined;
+        return {
+            metadata: id => this.revisionMetadata(id),
+            list: options => this.revisionList(options),
+            readAtRevision: (id, revision) => this.readAtRevision(id, revision)
+        };
+    }
+    revisionColumn(table) {
+        const column = columnOf(table, RECORD_REVISION_COLUMN);
+        if (!column)
+            throw new CapabilityError('The record table needs its Storage revision migration.', 'UNAVAILABLE', {
+                reason: 'record-revision-column-missing', retryable: false, details: { recordKind: this.descriptor.id }
+            });
+        return column;
+    }
+    revisionLivePredicate(table) {
+        const deleted = softDeleteColumn(this.descriptor.softDelete);
+        if (!deleted)
+            return undefined;
+        const column = columnOf(table, deleted);
+        if (!column)
+            throw new CapabilityError('The record table needs its soft-delete column.', 'UNAVAILABLE', {
+                reason: 'record-soft-delete-column-missing', retryable: false, details: { recordKind: this.descriptor.id }
+            });
+        return isNull(column);
+    }
+    async revisionMetadata(id) {
+        const { database, table } = await this.context();
+        const rows = RowsSchema.parse(await database.select({ id: this.primaryColumn(table), revision: this.revisionColumn(table) }).from(table).where(and(eq(this.primaryColumn(table), id), this.revisionLivePredicate(table))).limit(1));
+        if (!rows[0])
+            return null;
+        const key = z.union([z.string(), z.number(), z.bigint()]).parse(rows[0].id);
+        return RecordRevisionMetadataSchema.parse({ id: String(key), revision: rows[0].revision });
+    }
+    async readAtRevision(id, revision) {
+        const { database, table } = await this.context();
+        const rows = RowsSchema.parse(await database.select().from(table).where(and(eq(this.primaryColumn(table), id), eq(this.revisionColumn(table), revision), this.revisionLivePredicate(table))).limit(1));
+        const row = rows[0];
+        if (row)
+            return { status: 'read', revision, value: this.parse(row) };
+        const current = await this.revisionMetadata(id);
+        return current ? { status: 'changed', revision: current.revision } : { status: 'not-found' };
+    }
+    async revisionList(options) {
+        const query = RecordRevisionQuerySchema.parse(options ?? {});
+        const { database, table } = await this.context();
+        const predicate = and(this.where(table, this.readFilter(query.where, false)), this.revisionLivePredicate(table));
+        let select = database.select({ id: this.primaryColumn(table), revision: this.revisionColumn(table) }).from(table);
+        if (predicate)
+            select = select.where(predicate);
+        const order = Array.isArray(query.orderBy) ? query.orderBy : Object.entries(query.orderBy ?? {}).map(([field, direction]) => ({ field, direction }));
+        const ordering = order.map(item => {
+            const column = columnOf(table, item.field);
+            if (!column)
+                this.invalidFilter(false, 'unknown-column', item.field);
+            return item.direction === 'desc' ? desc(column) : asc(column);
+        });
+        if (!order.some(item => item.field === this.primaryKey))
+            ordering.push(asc(this.primaryColumn(table)));
+        select = select.orderBy(...ordering);
+        if (query.limit !== undefined)
+            select = select.limit(query.limit + 1);
+        if (query.offset !== undefined)
+            select = select.offset(query.offset);
+        const rows = RowsSchema.parse(await select);
+        const hasMore = query.limit !== undefined && rows.length > query.limit;
+        const items = (hasMore ? rows.slice(0, query.limit) : rows).map(row => {
+            const key = z.union([z.string(), z.number(), z.bigint()]).parse(row.id);
+            return RecordRevisionMetadataSchema.parse({ id: String(key), revision: row.revision });
+        });
+        const page = { items, hasMore };
+        if (query.limit === undefined || query.includeTotal) {
+            let count = database.select({ count: countRows() }).from(table);
+            if (predicate)
+                count = count.where(predicate);
+            page.total = CountRowsSchema.parse(await count)[0]?.count ?? 0;
+        }
+        return page;
+    }
+    constructor(adapterId, databaseHost, descriptor, runtime, dialect, supportsTransactions = true, supportsConditionalWrites = true) {
+        this.adapterId = adapterId;
+        this.databaseHost = databaseHost;
+        this.descriptor = descriptor;
+        this.runtime = runtime;
+        this.dialect = dialect;
+        this.supportsTransactions = supportsTransactions;
+        this.tableName = descriptor.tableName;
+        this.supportsConditionalWrites = supportsConditionalWrites;
+        assertRecordRevisionSchema(descriptor);
+        this.primaryKey = descriptor.primaryKey;
+        if (!(descriptor.schema instanceof z.ZodType)) {
+            throw new CapabilityError('storage.drizzle record descriptors need a Zod schema.', 'INVALID_INPUT', {
+                reason: 'record-schema-invalid',
+                retryable: false,
+                details: { recordKind: descriptor.id }
+            });
+        }
+        // SAFETY: descriptor.schema is a Zod schema (checked above); `T` is the row type the caller declares for it through record<T>().
+        this.schema = descriptor.schema;
+        this.relations = descriptor.relations ?? {};
+    }
+    /** Whether this adapter's descriptor-built table was found present (checked once; a failed check is retried). */
+    tableChecked;
+    /**
+     * The host schema's table wins; without one, the table the descriptor declares (its migration
+     * creates it), confirmed present on first use so a missing or misnamed table refuses typed
+     * instead of failing later as raw SQL.
+     */
+    async context() {
+        const database = hostDatabase(this.databaseHost);
+        const declared = hostTable(database, this.tableName);
+        if (declared)
+            return { database, table: declared };
+        const table = recordTable(this.descriptor, this.dialect);
+        if (this.tableChecked) {
+            await this.tableChecked;
+            return { database, table };
+        }
+        const check = this.assertTablePresent(database, table);
+        this.tableChecked = check;
+        const checked = await settle(() => check);
+        if (!checked.ok) {
+            // A failed check is not remembered: the next use asks again.
+            this.tableChecked = undefined;
+            throw checked.cause;
+        }
+        return { database, table };
+    }
+    async assertTablePresent(database, table) {
+        const probed = await settle(async () => { await database.select().from(table).limit(0); });
+        if (probed.ok)
+            return;
+        const message = (probed.cause instanceof Error ? probed.cause.message : probed.cause.description).toLowerCase();
+        if (message.includes('no such table') || (message.includes('relation') && message.includes('does not exist'))) {
+            throw new CapabilityError(`The ${this.tableName} table this record declares does not exist; apply the record's migration.`, 'UNAVAILABLE', {
+                reason: 'record-table-missing',
+                retryable: false,
+                details: { recordKind: this.descriptor.id, tableName: this.tableName },
+                recoveryHint: 'Create it from the descriptor (recordMigration) through the database owner, or declare it in the host schema.'
+            });
+        }
+        throw probed.cause;
+    }
+    primaryColumn(table) {
+        const column = columnOf(table, this.primaryKey);
+        if (!column) {
+            throw new CapabilityError('storage.drizzle record table has no primary key column.', 'INVALID_INPUT', {
+                reason: 'record-primary-key-column-missing',
+                retryable: false,
+                details: { tableName: this.tableName, primaryKey: this.primaryKey }
+            });
+        }
+        return column;
+    }
+    /** A filter the record cannot enforce, refused before any hook or SQL runs. */
+    invalidFilter(deleting, check, field, operator) {
+        const details = { tableName: this.tableName, check, field, operator };
+        if (deleting) {
+            throw new CapabilityError('storage.drizzle cannot enforce the deletion filter.', 'INVALID_INPUT', {
+                reason: 'record-delete-filter-invalid', retryable: false, details
+            });
+        }
+        throw new CapabilityError('storage.drizzle cannot enforce the record filter.', 'INVALID_INPUT', {
+            reason: 'record-filter-invalid', retryable: false, details
+        });
+    }
+    assertDateOperands(values, field, deleting) {
+        for (const operand of values) {
+            if (Number.isFinite(operand.getTime()))
+                continue;
+            if (deleting)
+                this.invalidFilter(true, 'invalid-date', field);
+            throw new CapabilityError('storage.drizzle cannot enforce an invalid Date filter.', 'INVALID_INPUT', {
+                reason: 'record-filter-date-invalid', retryable: false, details: { tableName: this.tableName, field }
+            });
+        }
+    }
+    /** A caller's filter read once into a field map; an absent filter (or, outside deletion, a falsy one) is no filter. */
+    readFilter(where, deleting) {
+        if (where === undefined || (!deleting && !where))
+            return undefined;
+        return parseAdapterInput(FilterSchema, where, {
+            message: deleting ? 'storage.drizzle cannot enforce the deletion filter.' : 'storage.drizzle cannot enforce the record filter.',
+            code: 'INVALID_INPUT',
+            reason: deleting ? 'record-delete-filter-invalid' : 'record-filter-invalid',
+            details: { tableName: this.tableName, check: 'field-map' }
+        });
+    }
+    where(table, fields, deleting = false) {
+        if (!fields)
+            return undefined;
+        const conditions = Object.entries(fields).flatMap(([field, expected]) => {
+            const column = columnOf(table, field);
+            if (deleting && (!column || expected === undefined))
+                this.invalidFilter(true, 'unknown-column-or-missing-value', field);
+            if (!isComparison(expected)) {
+                this.assertDateOperands((Array.isArray(expected) ? expected : [expected]).filter((operand) => operand instanceof Date), field, deleting);
+                if (!column)
+                    return this.invalidFilter(false, 'unknown-column', field);
+                if (expected === undefined) {
+                    if (!this.optionalOnlyFields().has(field))
+                        return this.invalidFilter(deleting, 'nullable-undefined-ambiguous', field);
+                    return [isNull(column)];
+                }
+                return [expected === null ? isNull(column) : eq(column, expected)];
+            }
+            const comparison = parseAdapterInput(FilterSchema, expected, {
+                message: deleting ? 'storage.drizzle cannot enforce the deletion filter.' : 'storage.drizzle cannot enforce the record filter.',
+                code: 'INVALID_INPUT',
+                reason: deleting ? 'record-delete-filter-invalid' : 'record-filter-invalid',
+                details: { tableName: this.tableName, field, check: 'operator-map' }
+            });
+            // An operator object with no operator constrains nothing: refused, never read as "every row".
+            if (!Object.keys(comparison).length)
+                this.invalidFilter(deleting, 'empty-comparison', field);
+            if ('hasNot' in comparison) {
+                const member = comparison.hasNot;
+                assertArrayField(field, member);
+                this.arrayColumn(table, field, member);
+            }
+            if ('hasAll' in comparison) {
+                for (const member of assertArrayMembers(field, comparison.hasAll))
+                    this.arrayColumn(table, field, member);
+            }
+            if (!column)
+                return this.invalidFilter(false, 'unknown-column', field);
+            return Object.entries(comparison).flatMap(([key, value]) => {
+                const known = RecordFilterOperatorSchema.safeParse(key);
+                if (!known.success)
+                    return this.invalidFilter(deleting, 'unknown-operator', field, key);
+                const operator = known.data;
+                if (RANGE_OPERATORS.includes(operator)) {
+                    this.assertDateOperands((Array.isArray(value) ? value : [value]).filter((operand) => operand instanceof Date), field, deleting);
+                }
+                if (deleting && value === undefined)
+                    this.invalidFilter(true, 'missing-operand', field, operator);
+                if (deleting && TEXT_OPERATORS.includes(operator) && !isText(value)) {
+                    this.invalidFilter(true, 'text-operand-required', field, operator);
+                }
+                switch (operator) {
+                    case 'hasAll':
+                        return assertArrayMembers(field, value).map(member => sql `EXISTS (SELECT 1 FROM json_each(COALESCE(${column}, '[]')) WHERE type = 'text' AND value = ${member})`);
+                    case 'hasNot': return [sql `NOT EXISTS (SELECT 1 FROM json_each(COALESCE(${column}, '[]')) WHERE type = 'text' AND value = ${value})`];
+                    case 'eq': {
+                        if (value === undefined) {
+                            if (!this.optionalOnlyFields().has(field))
+                                return this.invalidFilter(deleting, 'nullable-undefined-ambiguous', field, operator);
+                            return [isNull(column)];
+                        }
+                        return [value === null ? isNull(column) : eq(column, value)];
+                    }
+                    case 'ne': {
+                        if (value === undefined) {
+                            if (comparison.eq === null && !this.optionalOnlyFields().has(field))
+                                return [];
+                            if (!this.optionalOnlyFields().has(field))
+                                return this.invalidFilter(deleting, 'nullable-undefined-ambiguous', field, operator);
+                            return [isNotNull(column)];
+                        }
+                        return [value === null ? isNotNull(column) : ne(column, value)];
+                    }
+                    case 'gt': return [gt(column, value)];
+                    case 'gte': return [gte(column, value)];
+                    case 'lt': return [lt(column, value)];
+                    case 'lte': return [lte(column, value)];
+                    case 'in':
+                    case 'notIn': {
+                        if (!Array.isArray(value) || (deleting && value.includes(undefined))) {
+                            this.invalidFilter(deleting, 'array-operand-required', field, operator);
+                        }
+                        return [operator === 'in' ? inArray(column, value) : notInArray(column, value)];
+                    }
+                    case 'like': return [like(column, String(value))];
+                    case 'ilike': return [ilike(column, String(value))];
+                    case 'contains': return [like(column, `%${String(value)}%`)];
+                    case 'startsWith': return [like(column, `${String(value)}%`)];
+                    case 'endsWith': return [like(column, `%${String(value)}`)];
+                    case 'isNull':
+                        if (deleting && value !== true)
+                            this.invalidFilter(true, 'true-operand-required', field, operator);
+                        // On a read `isNull: false` is `IS NOT NULL` (as LocalDB compiles it), never a dropped clause.
+                        return value ? [isNull(column)] : [isNotNull(column)];
+                    case 'isNotNull':
+                        if (deleting && value !== true)
+                            this.invalidFilter(true, 'true-operand-required', field, operator);
+                        return value ? [isNotNull(column)] : [isNull(column)];
+                    case 'between': {
+                        if (!Array.isArray(value) || value.length !== 2 || (deleting && value.includes(undefined))) {
+                            this.invalidFilter(deleting, 'two-bounds-required', field, operator);
+                        }
+                        const range = and(gte(column, value[0]), lte(column, value[1]));
+                        return range ? [range] : [];
+                    }
+                }
+            });
+        });
+        return conditions.length ? and(...conditions) : undefined;
+    }
+    arrayColumn(table, field, value) {
+        assertArrayField(field, value);
+        if (!SQLITE_DIALECTS.includes(this.dialect ?? ''))
+            unsupportedArrayOperation(`storage.drizzle dialect '${this.dialect ?? 'unconfigured'}'`);
+        const column = columnOf(table, field);
+        if (!column) {
+            throw new CapabilityError('storage.drizzle has no such array column in the record table.', 'INVALID_INPUT', {
+                reason: 'record-array-column-missing', retryable: false, details: { tableName: this.tableName, field }
+            });
+        }
+        return column;
+    }
+    optionalFields;
+    /** Schema fields that accept `undefined` (optional) but not `null` (so a relational `NULL` column represents absence). */
+    optionalOnlyFields() {
+        if (this.optionalFields)
+            return this.optionalFields;
+        const schemaFields = schemaFieldsOf(this.schema);
+        const fields = new Set();
+        for (const [field, fieldSchema] of Object.entries(schemaFields)) {
+            if (fieldSchema.safeParse(undefined).success && !fieldSchema.safeParse(null).success)
+                fields.add(field);
+        }
+        this.optionalFields = fields;
+        return fields;
+    }
+    normalizeOptionalNulls(row) {
+        for (const field of this.optionalOnlyFields()) {
+            if (row[field] === null)
+                delete row[field];
+        }
+    }
+    parse(row) {
+        if (this.descriptor.versioning)
+            delete row[RECORD_REVISION_COLUMN];
+        this.normalizeOptionalNulls(row);
+        if (this.descriptor.validateOnRead)
+            return this.schema.parse(row);
+        // SAFETY: validateOnRead is false (checked above): the descriptor declares its schema describes the bound table's rows and opts out of read parsing.
+        return row;
+    }
+    /** A caller's record input read once into a field map. */
+    readInput(input) {
+        const row = parseAdapterInput(RowSchema, input, {
+            message: 'storage.drizzle record input must be a field map.',
+            code: 'INVALID_INPUT',
+            reason: 'record-input-invalid',
+            details: { tableName: this.tableName }
+        });
+        if (this.descriptor.versioning && Object.hasOwn(row, RECORD_REVISION_COLUMN))
+            throw new CapabilityError('Storage revision metadata cannot be written as record data.', 'INVALID_INPUT', {
+                reason: 'record-revision-field-reserved', retryable: false
+            });
+        return row;
+    }
+    notFound(id) {
+        return new CapabilityError('storage.drizzle record not found.', 'NOT_FOUND', {
+            reason: 'record-absent',
+            retryable: false,
+            details: { tableName: this.tableName, id }
+        });
+    }
+    async runHook(phase, row) {
+        if (this.descriptor.versioning && phase.startsWith('after'))
+            delete row[RECORD_REVISION_COLUMN];
+        const hook = this.descriptor[phase];
+        if (hook !== undefined)
+            await z.function({ input: [z.unknown()] }).parse(hook)(row);
+    }
+    emitLifecycle(phase, row) {
+        if (this.descriptor.versioning)
+            delete row[RECORD_REVISION_COLUMN];
+        const logger = getLogger('storage:drizzle-adapter', this.runtime);
+        try {
+            this.runtime.hooks('storage/record').emit(phase, {
+                recordId: row[this.primaryKey], recordKind: this.descriptor.id,
+                tableName: this.tableName, data: row
+            });
+        }
+        catch (error) {
+            logger.warn('storage/record lifecycle hook failed', {
+                error: valueFreeFailure(CaughtFailureSchema.parse(error)), phase, recordKind: this.descriptor.id
+            });
+        }
+    }
+    readPrimaryKey(record) {
+        const row = RowSchema.parse(record);
+        return z.string().parse(row[this.primaryKey]);
+    }
+    async prepare(value, creating) {
+        const next = { ...value };
+        if (creating && this.descriptor.autoId !== false && next[this.primaryKey] == null) {
+            next[this.primaryKey] = crypto.randomUUID();
+        }
+        if (this.descriptor.timestamps) {
+            // The descriptor's own timestamp fields, stamped in the form the schema reads (epoch milliseconds, a Date or an ISO string).
+            const now = new Date();
+            const columns = new Map(recordColumns(this.descriptor).map((column) => [column.field, column]));
+            const stamp = (field) => {
+                const column = columns.get(field);
+                if (column?.kind === 'integer')
+                    return now.getTime();
+                return column?.valueIsDate === false ? now.toISOString() : now;
+            };
+            const createdAt = timestampColumn(this.descriptor.timestamps, 'createdAt');
+            const updatedAt = timestampColumn(this.descriptor.timestamps, 'updatedAt');
+            if (creating && createdAt && next[createdAt] == null)
+                next[createdAt] = stamp(createdAt);
+            if (updatedAt)
+                next[updatedAt] = stamp(updatedAt);
+        }
+        await this.runHook(creating ? 'beforeCreate' : 'beforeUpdate', next);
+        if (this.descriptor.versioning && Object.hasOwn(next, RECORD_REVISION_COLUMN))
+            throw new CapabilityError('Storage revision metadata cannot be written by a record hook.', 'INVALID_INPUT', {
+                reason: 'record-revision-field-reserved', retryable: false
+            });
+        return this.descriptor.validateOnWrite ? RowSchema.parse(this.schema.parse(next)) : next;
+    }
+    rethrowDriverConstraintFailure(cause) {
+        const DriverErrorNodeSchema = z.object({
+            code: z.string().optional(),
+            extendedCode: z.string().optional(),
+            errno: z.number().optional(),
+            rawCode: z.number().optional(),
+            retryable: z.boolean().optional(),
+            cause: z.unknown().optional()
+        });
+        const uniqueCodes = new Set(['SQLITE_CONSTRAINT_UNIQUE', 'SQLITE_CONSTRAINT_PRIMARYKEY', '23505']);
+        const uniqueErrnos = new Set([1555, 2067]);
+        const foreignKeyCodes = new Set(['SQLITE_CONSTRAINT_FOREIGNKEY', '23503']);
+        const foreignKeyErrnos = new Set([787]);
+        let typedRetryable;
+        let current = cause;
+        for (let depth = 0; depth < 4 && current; depth++) {
+            if (current instanceof CapabilityError) {
+                const failure = valueFreeFailure(CaughtFailureSchema.parse(cause));
+                throw new CapabilityError(`Database write failed on ${this.tableName}.`, current.code, {
+                    reason: current.reason,
+                    retryable: current.retryable,
+                    details: { tableName: this.tableName, failure },
+                    cause: failure
+                });
+            }
+            const parsed = DriverErrorNodeSchema.safeParse(current);
+            if (!parsed.success)
+                break;
+            const { code, extendedCode, errno, rawCode, retryable, cause: nextCause } = parsed.data;
+            if (typedRetryable === undefined && retryable !== undefined) {
+                typedRetryable = retryable;
+            }
+            const matchedUniqueCode = extendedCode && uniqueCodes.has(extendedCode) ? extendedCode : code && uniqueCodes.has(code) ? code : undefined;
+            if (matchedUniqueCode || (errno !== undefined && uniqueErrnos.has(errno)) || (rawCode !== undefined && uniqueErrnos.has(rawCode))) {
+                const driverCode = matchedUniqueCode ?? String(errno ?? rawCode);
+                const failure = valueFreeFailure(CaughtFailureSchema.parse(cause));
+                throw new CapabilityError(`Unique constraint failed on ${this.tableName}.`, 'CONFLICT', {
+                    reason: 'record-unique-constraint-conflict',
+                    retryable: false,
+                    details: { tableName: this.tableName, driverCode, failure },
+                    cause: failure
+                });
+            }
+            const matchedForeignKeyCode = extendedCode && foreignKeyCodes.has(extendedCode) ? extendedCode : code && foreignKeyCodes.has(code) ? code : undefined;
+            if (matchedForeignKeyCode || (errno !== undefined && foreignKeyErrnos.has(errno)) || (rawCode !== undefined && foreignKeyErrnos.has(rawCode))) {
+                const driverCode = matchedForeignKeyCode ?? String(errno ?? rawCode);
+                const failure = valueFreeFailure(CaughtFailureSchema.parse(cause));
+                throw new CapabilityError(`Foreign key constraint failed on ${this.tableName}.`, 'CONFLICT', {
+                    reason: 'record-foreign-key-conflict',
+                    retryable: false,
+                    details: { tableName: this.tableName, driverCode, failure },
+                    cause: failure
+                });
+            }
+            current = nextCause;
+        }
+        const failure = valueFreeFailure(CaughtFailureSchema.parse(cause));
+        throw new CapabilityError(`Database write failed on ${this.tableName}.`, 'UNAVAILABLE', {
+            reason: 'record-write-failed',
+            retryable: typedRetryable,
+            details: { tableName: this.tableName, failure },
+            cause: failure
+        });
+    }
+    async insertRow(input) {
+        const { database, table } = await this.context();
+        const primaryCol = this.primaryColumn(table);
+        const row = await this.prepare(input, true);
+        if (this.descriptor.versioning) {
+            this.revisionColumn(table);
+            row[RECORD_REVISION_COLUMN] = crypto.randomUUID();
+        }
+        const attempt = await settle(async () => RowsSchema.parse(await database.insert(table).values(row).onConflictDoNothing({ target: primaryCol }).returning()));
+        if (!attempt.ok) {
+            return this.rethrowDriverConstraintFailure(attempt.cause);
+        }
+        const inserted = attempt.value;
+        if (!inserted[0]) {
+            throw new CapabilityError(`Record with duplicate ${this.primaryKey} already exists in ${this.tableName}.`, 'CONFLICT', {
+                reason: 'record-identity-conflict',
+                retryable: true,
+                details: { tableName: this.tableName, primaryKey: this.primaryKey }
+            });
+        }
+        const persisted = inserted[0];
+        this.normalizeOptionalNulls(persisted);
+        await this.runHook('afterCreate', persisted);
+        this.emitLifecycle('afterCreate', persisted);
+        return this.parse(persisted);
+    }
+    async create(data) {
+        return this.insertRow(this.readInput(data));
+    }
+    async createMany(data) {
+        if (!data.length)
+            return [];
+        const { database, table } = await this.context();
+        const rows = await Promise.all(data.map((item) => this.prepare(this.readInput(item), true)));
+        if (this.descriptor.versioning) {
+            this.revisionColumn(table);
+            for (const row of rows)
+                row[RECORD_REVISION_COLUMN] = crypto.randomUUID();
+        }
+        const result = RowsSchema.parse(await database.insert(table).values(rows).returning());
+        for (const row of result) {
+            this.normalizeOptionalNulls(row);
+            await this.runHook('afterCreate', row);
+            this.emitLifecycle('afterCreate', row);
+        }
+        return result.map((row) => this.parse(row));
+    }
+    /** What relation loading reads of this record: its kind, primary key, declared relations and runtime. */
+    get relationOwner() {
+        return { recordKind: this.descriptor.id, primaryKey: this.primaryKey, relations: this.relations, runtime: this.runtime };
+    }
+    /** Each row with the relations `include` names loaded from their target records (`storage/record` by id). */
+    withRelations(rows, include) {
+        return Promise.all(rows.map((row) => loadRecordRelations(this.relationOwner, row, include)));
+    }
+    async get(id, options) {
+        const { database, table } = await this.context();
+        const rows = RowsSchema.parse(await database.select().from(table).where(eq(this.primaryColumn(table), id)).limit(1));
+        return rows[0] ? loadRecordRelations(this.relationOwner, this.parse(rows[0]), options?.include) : null;
+    }
+    async getOrThrow(id, options) {
+        const value = await this.get(id, options);
+        if (!value)
+            throw this.notFound(id);
+        return value;
+    }
+    async getMany(ids, options) {
+        if (!ids.length)
+            return [];
+        const { database, table } = await this.context();
+        const rows = RowsSchema.parse(await database.select().from(table).where(inArray(this.primaryColumn(table), ids)));
+        return this.withRelations(rows.map((row) => this.parse(row)), options?.include);
+    }
+    async list(options = {}) {
+        const { database, table } = await this.context();
+        const query = parseAdapterInput(ListOptionsSchema, options, {
+            message: 'storage.drizzle cannot read the list options.',
+            code: 'INVALID_INPUT',
+            reason: 'record-query-invalid',
+            details: { tableName: this.tableName }
+        });
+        const filter = this.readFilter(query.where, false);
+        const predicate = this.where(table, filter);
+        let select = database.select().from(table);
+        if (predicate)
+            select = select.where(predicate);
+        const order = Array.isArray(query.orderBy)
+            ? query.orderBy
+            : Object.entries(query.orderBy ?? {}).flatMap(([field, direction]) => (direction ? [{ field, direction }] : []));
+        const clauses = order.flatMap(({ field, direction }) => {
+            const column = columnOf(table, field);
+            return column ? [direction === 'desc' ? desc(column) : asc(column)] : [];
+        });
+        if (clauses.length)
+            select = select.orderBy(...clauses);
+        if (query.limit !== undefined)
+            select = select.limit(query.limit);
+        if (query.offset !== undefined)
+            select = select.offset(query.offset);
+        const rows = RowsSchema.parse(await select);
+        const items = await this.withRelations(rows.map((row) => this.parse(row)), options.include);
+        return { items, total: await this.countWhere(table, filter) };
+    }
+    async findFirst(options = {}) {
+        const result = await this.list({ ...options, limit: 1 });
+        return result.items[0] ?? null;
+    }
+    async findFirstOrThrow(options) {
+        const value = await this.findFirst(options);
+        if (!value)
+            throw this.notFound(undefined);
+        return value;
+    }
+    async exists(id) { return (await this.get(id)) !== null; }
+    async count(where) {
+        const { table } = await this.context();
+        return this.countWhere(table, this.readFilter(where, false));
+    }
+    async countWhere(table, filter) {
+        const { database } = await this.context();
+        const predicate = this.where(table, filter);
+        let query = database.select({ count: countRows() }).from(table);
+        if (predicate)
+            query = query.where(predicate);
+        const rows = CountRowsSchema.parse(await query);
+        return rows[0]?.count ?? 0;
+    }
+    unsupported(reason, message) {
+        throw new CapabilityError(message, 'UNAVAILABLE', { reason, retryable: false, details: { tableName: this.tableName } });
+    }
+    async search() { return this.unsupported('record-search-unsupported', 'storage.drizzle does not advertise full-text search.'); }
+    async getDescendants() { return this.unsupported('record-hierarchy-unsupported', 'storage.drizzle does not advertise hierarchy queries.'); }
+    async getAncestors() { return this.unsupported('record-hierarchy-unsupported', 'storage.drizzle does not advertise hierarchy queries.'); }
+    async getTree() { return this.unsupported('record-hierarchy-unsupported', 'storage.drizzle does not advertise hierarchy queries.'); }
+    async update(id, data, options) {
+        const updated = await this.updateWithConditions(id, this.readInput(data), options);
+        if (updated instanceof OptimisticLockError)
+            throw updated;
+        return updated;
+    }
+    /** One conditional update: the updated record, or the optimistic-lock conflict when its precondition no longer holds. */
+    async updateWithConditions(id, data, options, bulkWhere) {
+        const { database, table } = await this.context();
+        const bulkPredicate = this.where(table, bulkWhere);
+        const extraWhere = this.readFilter(options?.where, false);
+        const extraPredicate = this.where(table, extraWhere);
+        if (options && Object.hasOwn(options, 'addToSet') && !SQLITE_DIALECTS.includes(this.dialect ?? '')) {
+            unsupportedArrayOperation(`storage.drizzle dialect '${this.dialect ?? 'unconfigured'}'`);
+        }
+        for (const [field, value] of Object.entries(options?.addToSet ?? {}))
+            this.arrayColumn(table, field, value);
+        const current = RowSchema.parse(await this.getOrThrow(id));
+        const snapshot = structuredClone(current);
+        const draft = { ...current, ...data };
+        const additions = applySetAdditions(draft, data, options);
+        const row = await this.prepare(draft, false);
+        const patch = updatePatch(snapshot, row, data, additions);
+        const optionalOnly = this.optionalOnlyFields();
+        for (const [field, value] of Object.entries(patch)) {
+            if (value !== undefined)
+                continue;
+            if (!optionalOnly.has(field)) {
+                throw new CapabilityError(`storage.drizzle cannot clear field '${field}' to undefined in '${this.tableName}' because the schema also accepts null; relational NULL cannot distinguish null from undefined.`, 'INVALID_INPUT', {
+                    reason: 'record-nullable-undefined-unsupported',
+                    retryable: false,
+                    details: { tableName: this.tableName, field }
+                });
+            }
+            patch[field] = null;
+        }
+        if (this.descriptor.versioning) {
+            this.revisionColumn(table);
+            patch[RECORD_REVISION_COLUMN] = crypto.randomUUID();
+        }
+        for (const [field, value] of Object.entries(additions)) {
+            const column = this.arrayColumn(table, field, value);
+            patch[field] = sql `CASE WHEN EXISTS (SELECT 1 FROM json_each(COALESCE(${column}, '[]')) WHERE type = 'text' AND value = ${value})
+				THEN COALESCE(${column}, '[]') ELSE json_insert(COALESCE(${column}, '[]'), '$[#]', ${value}) END`;
+        }
+        const primary = this.primaryColumn(table);
+        // A no-op SQL update preserves the atomic precondition and lifecycle boundary.
+        if (!Object.keys(patch).length)
+            patch[this.primaryKey] = primary;
+        const updateAttempt = await settle(async () => RowsSchema.parse(await database.update(table).set(patch).where(and(eq(primary, id), bulkPredicate, extraPredicate)).returning()));
+        if (!updateAttempt.ok) {
+            return this.rethrowDriverConstraintFailure(updateAttempt.cause);
+        }
+        const result = updateAttempt.value;
+        const updated = result[0];
+        const precondition = extraWhere ?? bulkWhere;
+        if (!updated && precondition)
+            return new OptimisticLockError(this.tableName, id, precondition);
+        if (!updated)
+            throw this.notFound(id);
+        this.normalizeOptionalNulls(updated);
+        await this.runHook('afterUpdate', updated);
+        this.emitLifecycle('afterUpdate', updated);
+        return this.parse(updated);
+    }
+    async updateMany(where, data, options) {
+        const { table } = await this.context();
+        this.where(table, this.readFilter(options?.where, false));
+        const bulkWhere = this.readFilter(where, false);
+        const changes = this.readInput(data);
+        const result = await this.list({ where });
+        let count = 0;
+        for (const record of result.items) {
+            const updated = await this.updateWithConditions(this.readPrimaryKey(record), changes, options, bulkWhere);
+            // A record a peer changed out of the bulk selection is skipped, not overwritten.
+            if (!(updated instanceof OptimisticLockError))
+                count++;
+        }
+        return { count, success: count > 0 };
+    }
+    async upsert(id, create, update) {
+        return (await this.exists(id)) ? this.update(id, update) : this.insertRow({ ...this.readInput(create), [this.primaryKey]: id });
+    }
+    async delete(id, options) {
+        return this.deleteWithConditions(id, undefined, options);
+    }
+    async deleteWithConditions(id, bulkWhere, options) {
+        const { database, table } = await this.context();
+        const bulkPredicate = this.where(table, bulkWhere, true);
+        const extraPredicate = this.where(table, this.readFilter(options?.where, true), true);
+        const current = await this.get(id);
+        if (!current)
+            return { count: 0, success: false };
+        const row = RowSchema.parse(current);
+        await this.runHook('beforeDelete', row);
+        const result = RowsSchema.parse(await database.delete(table).where(and(eq(this.primaryColumn(table), id), bulkPredicate, extraPredicate)).returning());
+        const deleted = result[0];
+        if (deleted) {
+            await this.runHook('afterDelete', deleted);
+            this.emitLifecycle('afterDelete', deleted);
+        }
+        return { count: result.length, success: result.length > 0 };
+    }
+    async deleteMany(where, options) {
+        const { database, table } = await this.context();
+        const bulkWhere = this.readFilter(where, true);
+        const bulkPredicate = this.where(table, bulkWhere, true);
+        const extraPredicate = this.where(table, this.readFilter(options?.where, true), true);
+        if (this.descriptor.beforeDelete === undefined && this.descriptor.afterDelete === undefined) {
+            const rows = RowsSchema.parse(await database.delete(table).where(and(bulkPredicate, extraPredicate)).returning());
+            for (const row of rows)
+                this.emitLifecycle('afterDelete', row);
+            return { count: rows.length, success: rows.length > 0 };
+        }
+        const result = await this.list({ where });
+        let count = 0;
+        for (const record of result.items) {
+            const deleted = await this.deleteWithConditions(this.readPrimaryKey(record), bulkWhere, options);
+            count += deleted.count;
+        }
+        return { count, success: count > 0 };
+    }
+    async restore() { return this.unsupported('record-restore-unsupported', 'storage.drizzle restore requires an owner soft-delete policy.'); }
+    async aggregate(options) {
+        const values = RowsSchema.parse((await this.list({ where: options.where })).items);
+        if (options.function === 'count')
+            return [{ value: values.length }];
+        const field = isText(options.field) ? options.field : '';
+        const numbers = values.map((value) => Number(value[field])).filter(Number.isFinite);
+        if (!numbers.length)
+            return [{ value: 0 }];
+        const value = options.function === 'sum' ? numbers.reduce((a, b) => a + b, 0)
+            : options.function === 'avg' ? numbers.reduce((a, b) => a + b, 0) / numbers.length
+                : options.function === 'min' ? Math.min(...numbers) : Math.max(...numbers);
+        return [{ value }];
+    }
+    async transaction(fn) {
+        if (!this.supportsTransactions) {
+            throw new Error(`${this.adapterId} does not support interactive transactions.`);
+        }
+        const { database } = await this.context();
+        return database.transaction(() => fn({ id: crypto.randomUUID(), startTime: Date.now(), isActive: true }));
+    }
+    async *stream(options) {
+        for (const item of (await this.list(options)).items)
+            yield item;
+    }
+    async batch(operations) {
+        const results = [];
+        for (const operation of operations) {
+            if (operation.type === 'create')
+                results.push(await this.insertRow(this.readInput(operation.data)));
+            if (operation.type === 'update') {
+                const updated = await this.updateWithConditions(String(operation.id), this.readInput(operation.data));
+                if (updated instanceof OptimisticLockError)
+                    throw updated;
+                results.push(updated);
+            }
+            if (operation.type === 'delete')
+                results.push(await this.delete(String(operation.id)));
+        }
+        return results;
+    }
+    async raw() { return this.unsupported('record-raw-query-unsupported', 'Use the typed host database context for raw Drizzle queries.'); }
+    async queryRaw() { return this.unsupported('record-raw-query-unsupported', 'Use the typed host database context for raw Drizzle queries.'); }
+    async validate(data) {
+        const result = this.schema.safeParse(data);
+        return result.success ? { success: true, data: result.data } : { success: false, errors: result.error };
+    }
+    async initialize() { await this.context(); }
+    getAdapterId() { return this.adapterId; }
+    async close() { }
+}
+//# sourceMappingURL=drizzle.adapter.impl.js.map