@puzzle-ui/storage-d1 0.0.0-stage → 0.5.0

package/dist/d1.adapter.d.cts

@@ -0,0 +1,30 @@
+import { D1StorageAdapterOptions } from "./d1.types.cjs";
+import { StorageAdapter, StorageBatchOperation, StorageBatchResult, StorageCapabilities, StorageCapabilityReport, StorageCollection, StorageCollectionName, StorageCondition, StorageCursorQuery, StoragePage, StorageQuery, StorageRecord, StorageUpdate } from "@puzzle-ui/storage";
+export declare class D1StorageAdapter implements StorageAdapter {
+  readonly capabilities: StorageCapabilities;
+  private readonly database;
+  private readonly prefix;
+  constructor(options: D1StorageAdapterOptions);
+  getCapabilities(): StorageCapabilityReport;
+  private table;
+  private prepare;
+  private run;
+  private first;
+  private all;
+  private insertStatement;
+  registerCollection<T extends StorageRecord>(definition: StorageCollection<T>): Promise<void>;
+  findById<T extends StorageRecord>(collection: StorageCollectionName, id: string): Promise<T | null>;
+  findOne<T extends StorageRecord>(collection: StorageCollectionName, query: StorageQuery<T>): Promise<T | null>;
+  findMany<T extends StorageRecord>(collection: StorageCollectionName, query?: StorageQuery<T>): Promise<readonly T[]>;
+  findPage<T extends StorageRecord>(collection: StorageCollectionName, query: StorageCursorQuery<T>): Promise<StoragePage<T>>;
+  insert<T extends StorageRecord>(collection: StorageCollectionName, record: Parameters<StorageAdapter["insert"]>[1]): Promise<T>;
+  upsert<T extends StorageRecord>(collection: StorageCollectionName, query: StorageQuery<T>, record: Parameters<StorageAdapter["insert"]>[1]): Promise<T>;
+  private buildUpdate;
+  update<T extends StorageRecord>(collection: StorageCollectionName, id: string, changes: StorageUpdate<T>, condition?: StorageCondition): Promise<T | null>;
+  updateMany<T extends StorageRecord>(collection: StorageCollectionName, query: StorageQuery<T>, changes: StorageUpdate<T>): Promise<number>;
+  delete<T extends StorageRecord>(collection: StorageCollectionName, id: string, condition?: StorageCondition): Promise<boolean>;
+  deleteMany<T extends StorageRecord>(collection: StorageCollectionName, query: StorageQuery<T>): Promise<number>;
+  exists<T extends StorageRecord>(collection: StorageCollectionName, query: StorageQuery<T>): Promise<boolean>;
+  count<T extends StorageRecord>(collection: StorageCollectionName, query?: StorageQuery<T>): Promise<number>;
+  atomicBatch<T extends StorageRecord>(operations: readonly StorageBatchOperation<T>[]): Promise<StorageBatchResult<T>>;
+}

package/dist/d1.adapter.d.ts

@@ -0,0 +1,30 @@
+import { D1StorageAdapterOptions } from "./d1.types.js";
+import { StorageAdapter, StorageBatchOperation, StorageBatchResult, StorageCapabilities, StorageCapabilityReport, StorageCollection, StorageCollectionName, StorageCondition, StorageCursorQuery, StoragePage, StorageQuery, StorageRecord, StorageUpdate } from "@puzzle-ui/storage";
+export declare class D1StorageAdapter implements StorageAdapter {
+  readonly capabilities: StorageCapabilities;
+  private readonly database;
+  private readonly prefix;
+  constructor(options: D1StorageAdapterOptions);
+  getCapabilities(): StorageCapabilityReport;
+  private table;
+  private prepare;
+  private run;
+  private first;
+  private all;
+  private insertStatement;
+  registerCollection<T extends StorageRecord>(definition: StorageCollection<T>): Promise<void>;
+  findById<T extends StorageRecord>(collection: StorageCollectionName, id: string): Promise<T | null>;
+  findOne<T extends StorageRecord>(collection: StorageCollectionName, query: StorageQuery<T>): Promise<T | null>;
+  findMany<T extends StorageRecord>(collection: StorageCollectionName, query?: StorageQuery<T>): Promise<readonly T[]>;
+  findPage<T extends StorageRecord>(collection: StorageCollectionName, query: StorageCursorQuery<T>): Promise<StoragePage<T>>;
+  insert<T extends StorageRecord>(collection: StorageCollectionName, record: Parameters<StorageAdapter["insert"]>[1]): Promise<T>;
+  upsert<T extends StorageRecord>(collection: StorageCollectionName, query: StorageQuery<T>, record: Parameters<StorageAdapter["insert"]>[1]): Promise<T>;
+  private buildUpdate;
+  update<T extends StorageRecord>(collection: StorageCollectionName, id: string, changes: StorageUpdate<T>, condition?: StorageCondition): Promise<T | null>;
+  updateMany<T extends StorageRecord>(collection: StorageCollectionName, query: StorageQuery<T>, changes: StorageUpdate<T>): Promise<number>;
+  delete<T extends StorageRecord>(collection: StorageCollectionName, id: string, condition?: StorageCondition): Promise<boolean>;
+  deleteMany<T extends StorageRecord>(collection: StorageCollectionName, query: StorageQuery<T>): Promise<number>;
+  exists<T extends StorageRecord>(collection: StorageCollectionName, query: StorageQuery<T>): Promise<boolean>;
+  count<T extends StorageRecord>(collection: StorageCollectionName, query?: StorageQuery<T>): Promise<number>;
+  atomicBatch<T extends StorageRecord>(operations: readonly StorageBatchOperation<T>[]): Promise<StorageBatchResult<T>>;
+}

package/dist/d1.adapter.js

@@ -0,0 +1,531 @@
+import { StorageAtomicityError, StorageConflictError, StorageDuplicateError, StorageValidationError, validateQuery } from "@puzzle-ui/storage";
+// src/d1.adapter.ts
+const DATE_MARKER = "__puzzle_storage_date__";
+const serialize = (value) => JSON.stringify(value, (_key, current) => current instanceof Date ? { [DATE_MARKER]: current.toISOString() } : current);
+const deserialize = (value) => JSON.parse(value, (_key, current) => {
+	if (typeof current === "object" && current !== null && DATE_MARKER in current) {
+		const date = current[DATE_MARKER];
+		if (typeof date !== "string") throw new StorageValidationError("Invalid serialized D1 date.");
+		return new Date(date);
+	}
+	return current;
+});
+const encodeCursor = (payload) => ({ value: btoa(encodeURIComponent(JSON.stringify(payload))) });
+const decodeCursor = (cursor) => {
+	try {
+		return JSON.parse(decodeURIComponent(atob(cursor.value)));
+	} catch {
+		throw new StorageValidationError("Invalid D1 cursor.");
+	}
+};
+const quoteIdentifier = (value) => {
+	if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(value)) throw new StorageValidationError(`Invalid SQL identifier: ${value}`);
+	return `"${value}"`;
+};
+const jsonPath = (field) => {
+	if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(field)) throw new StorageValidationError(`Unsupported JSON field name: ${field}`);
+	return `$."${field}"`;
+};
+const sqlField = (field) => {
+	if (field === "id") return "id";
+	if (field === "createdAt") return "created_at";
+	if (field === "updatedAt") return "updated_at";
+	if (field === "revision") return "revision";
+	return `json_extract(data, '${jsonPath(field)}')`;
+};
+const sqlValue = (value) => value instanceof Date ? value.toISOString() : value;
+const buildComparison = (field, comparison) => {
+	const column = sqlField(field);
+	const value = comparison.value;
+	switch (comparison.operator) {
+		case "eq": return value === null ? {
+			sql: `${column} IS NULL`,
+			values: []
+		} : {
+			sql: `${column} = ?`,
+			values: [sqlValue(value)]
+		};
+		case "ne": return value === null ? {
+			sql: `${column} IS NOT NULL`,
+			values: []
+		} : {
+			sql: `${column} != ?`,
+			values: [sqlValue(value)]
+		};
+		case "gt": return {
+			sql: `${column} > ?`,
+			values: [sqlValue(value)]
+		};
+		case "gte": return {
+			sql: `${column} >= ?`,
+			values: [sqlValue(value)]
+		};
+		case "lt": return {
+			sql: `${column} < ?`,
+			values: [sqlValue(value)]
+		};
+		case "lte": return {
+			sql: `${column} <= ?`,
+			values: [sqlValue(value)]
+		};
+		case "exists": return {
+			sql: comparison.value ? `${column} IS NOT NULL` : `${column} IS NULL`,
+			values: []
+		};
+		case "in":
+		case "notIn": {
+			const values = value;
+			if (values.length === 0) return {
+				sql: comparison.operator === "in" ? "0 = 1" : "1 = 1",
+				values: []
+			};
+			const placeholders = values.map(() => "?").join(", ");
+			return {
+				sql: `${column} ${comparison.operator === "in" ? "IN" : "NOT IN"} (${placeholders})`,
+				values: values.map(sqlValue)
+			};
+		}
+		default: throw new StorageValidationError(`Unsupported query operator: ${comparison.operator}`);
+	}
+};
+const buildWhere = (where) => {
+	if (!where) return {
+		sql: "1 = 1",
+		values: []
+	};
+	const parts = [];
+	const values = [];
+	for (const [field, comparison] of Object.entries(where)) {
+		if (field === "and" || field === "or") {
+			const nested = comparison.map((item) => buildWhere(item));
+			if (nested.length === 0) continue;
+			parts.push(`(${nested.map((item) => item.sql).join(field === "and" ? " AND " : " OR ")})`);
+			for (const item of nested) values.push(...item.values);
+			continue;
+		}
+		const value = comparison;
+		if (typeof value !== "object" || value === null || !("operator" in value) || typeof value.operator !== "string" || !("value" in value)) throw new StorageValidationError(`Invalid query comparison for field: ${field}`);
+		const result = buildComparison(field, {
+			operator: value.operator,
+			value: value.value
+		});
+		parts.push(result.sql);
+		values.push(...result.values);
+	}
+	return {
+		sql: parts.length ? parts.join(" AND ") : "1 = 1",
+		values
+	};
+};
+const buildOrderBy = (orderBy) => {
+	const items = (orderBy ?? []).map((item) => `${sqlField(String(item.field))} ${item.direction === "desc" ? "DESC" : "ASC"}`);
+	if (!items.some((item) => item.startsWith("id "))) items.push("id ASC");
+	return items.join(", ");
+};
+const buildCursorWhere = (orderBy, values) => {
+	const fields = [...orderBy.map((item) => ({
+		field: String(item.field),
+		direction: item.direction
+	}))];
+	if (!fields.some((item) => item.field === "id")) fields.push({
+		field: "id",
+		direction: "asc"
+	});
+	const branches = [];
+	const parameters = [];
+	for (const [index, field] of fields.entries()) {
+		const conditions = [];
+		for (const [previous, prefix] of fields.slice(0, index).entries()) {
+			conditions.push(`${sqlField(prefix.field)} = ?`);
+			parameters.push(sqlValue(values[previous]));
+		}
+		const operator = field.direction === "desc" ? "<" : ">";
+		conditions.push(`${sqlField(field.field)} ${operator} ?`);
+		parameters.push(sqlValue(values[index]));
+		branches.push(`(${conditions.join(" AND ")})`);
+	}
+	return {
+		sql: `(${branches.join(" OR ")})`,
+		values: parameters
+	};
+};
+const cleanChanges = (changes) => {
+	const result = { ...changes };
+	delete result.id;
+	delete result.createdAt;
+	delete result.updatedAt;
+	delete result.revision;
+	return result;
+};
+const toRecord = (row) => {
+	return {
+		...deserialize(row.data),
+		id: row.id,
+		createdAt: new Date(row.created_at),
+		updatedAt: new Date(row.updated_at),
+		revision: row.revision
+	};
+};
+const getChanges = (result) => Number(result.meta?.changes ?? 0);
+const mapD1Error = (error) => {
+	const message = error instanceof Error ? error.message.toLowerCase() : "";
+	if (message.includes("unique constraint") || message.includes("primary key")) throw new StorageDuplicateError("d1_unique_constraint");
+	throw error;
+};
+var D1StorageAdapter = class {
+	capabilities = {
+		transactions: true,
+		atomicBatch: true,
+		conditionalWrites: true,
+		uniqueConstraints: true,
+		upsert: true,
+		cursorPagination: true,
+		migrations: true,
+		ttlIndexes: false
+	};
+	database;
+	prefix;
+	constructor(options) {
+		this.database = options.database;
+		this.prefix = options.tablePrefix ?? "puzzle_";
+	}
+	getCapabilities() {
+		return {
+			capabilities: this.capabilities,
+			limitations: ["D1 does not provide native TTL indexes. Expiration cleanup must be handled by an application or scheduled job."]
+		};
+	}
+	table(collection) {
+		return quoteIdentifier(`${this.prefix}${collection}`);
+	}
+	prepare(sql, values = []) {
+		return this.database.prepare(sql).bind(...values);
+	}
+	async run(sql, values = []) {
+		return this.prepare(sql, values).run();
+	}
+	async first(sql, values = []) {
+		return this.prepare(sql, values).first();
+	}
+	async all(sql, values = []) {
+		return (await this.prepare(sql, values).all()).results ?? [];
+	}
+	insertStatement(collection, record) {
+		const input = record;
+		const now = /* @__PURE__ */ new Date();
+		const createdAt = input.createdAt ?? now;
+		const updatedAt = input.updatedAt ?? now;
+		const revision = input.revision ?? 1;
+		const { id, createdAt: _createdAt, updatedAt: _updatedAt, revision: _revision, ...data } = input;
+		const result = {
+			id,
+			createdAt,
+			updatedAt,
+			revision,
+			...data
+		};
+		return {
+			sql: `INSERT INTO ${this.table(collection)}
+        (id, created_at, updated_at, revision, data)
+        VALUES (?, ?, ?, ?, ?)`,
+			values: [
+				id,
+				createdAt.toISOString(),
+				updatedAt.toISOString(),
+				revision,
+				serialize(data)
+			],
+			record: result
+		};
+	}
+	async registerCollection(definition) {
+		const table = this.table(definition.name);
+		await this.run(`
+      CREATE TABLE IF NOT EXISTS ${table} (
+        id TEXT PRIMARY KEY NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        revision INTEGER NOT NULL CHECK (revision > 0),
+        data TEXT NOT NULL CHECK (json_valid(data))
+      )
+    `);
+		for (const index of definition.indexes ?? []) {
+			const fields = index.fields.map((field) => {
+				return sqlField(String(field));
+			});
+			const unique = index.unique ? "UNIQUE " : "";
+			const name = quoteIdentifier(`${this.prefix}${definition.name}_${index.name}`);
+			await this.run(`
+        CREATE ${unique}INDEX IF NOT EXISTS ${name}
+        ON ${table} (${fields.join(", ")})
+      `);
+		}
+	}
+	async findById(collection, id) {
+		const row = await this.first(`SELECT * FROM ${this.table(collection)} WHERE id = ? LIMIT 1`, [id]);
+		return row ? toRecord(row) : null;
+	}
+	async findOne(collection, query) {
+		validateQuery(query);
+		const where = buildWhere(query.where);
+		const row = await this.first(`SELECT * FROM ${this.table(collection)}
+       WHERE ${where.sql}
+       ORDER BY ${buildOrderBy(query.orderBy)}
+       LIMIT 1`, where.values);
+		return row ? toRecord(row) : null;
+	}
+	async findMany(collection, query = {}) {
+		validateQuery(query);
+		const where = buildWhere(query.where);
+		const values = [...where.values];
+		let pagination = "";
+		if (query.limit !== void 0) {
+			pagination += " LIMIT ?";
+			values.push(query.limit);
+		} else if (query.offset !== void 0) pagination += " LIMIT -1";
+		if (query.offset !== void 0) {
+			pagination += " OFFSET ?";
+			values.push(query.offset);
+		}
+		return (await this.all(`SELECT * FROM ${this.table(collection)}
+       WHERE ${where.sql}
+       ORDER BY ${buildOrderBy(query.orderBy)}
+       ${pagination}`, values)).map((row) => toRecord(row));
+	}
+	async findPage(collection, query) {
+		if (!Number.isInteger(query.first) || query.first < 1) throw new StorageValidationError("Cursor page size must be a positive integer.");
+		const orderBy = query.orderBy ?? [{
+			field: "id",
+			direction: "asc"
+		}];
+		const base = buildWhere(query.where);
+		let whereSql = base.sql;
+		const values = [...base.values];
+		if (query.after) {
+			const cursor = decodeCursor(query.after);
+			const after = buildCursorWhere(orderBy, cursor.values);
+			whereSql = `(${whereSql}) AND ${after.sql}`;
+			values.push(...after.values);
+		}
+		values.push(query.first + 1);
+		const rows = await this.all(`SELECT * FROM ${this.table(collection)}
+       WHERE ${whereSql}
+       ORDER BY ${buildOrderBy(orderBy)}
+       LIMIT ?`, values);
+		const hasNextPage = rows.length > query.first;
+		const items = rows.slice(0, query.first);
+		const last = items.at(-1);
+		const cursorFields = [...orderBy.map((item) => String(item.field))];
+		if (!cursorFields.includes("id")) cursorFields.push("id");
+		const nextCursor = hasNextPage && last ? encodeCursor({ values: cursorFields.map((field) => {
+			if (field === "id") return last.id;
+			if (field === "createdAt") return last.created_at;
+			if (field === "updatedAt") return last.updated_at;
+			if (field === "revision") return last.revision;
+			return deserialize(last.data)[field];
+		}) }) : null;
+		return {
+			items: items.map((row) => toRecord(row)),
+			hasNextPage,
+			nextCursor
+		};
+	}
+	async insert(collection, record) {
+		const statement = this.insertStatement(collection, record);
+		try {
+			await this.run(statement.sql, statement.values);
+			return statement.record;
+		} catch (error) {
+			return mapD1Error(error);
+		}
+	}
+	async upsert(collection, query, record) {
+		const existing = await this.findOne(collection, query);
+		if (existing) {
+			const changes = { ...record };
+			const updated = await this.update(collection, existing.id, changes);
+			if (!updated) throw new StorageConflictError();
+			return updated;
+		}
+		return this.insert(collection, record);
+	}
+	buildUpdate(collection, id, changes, condition) {
+		const entries = Object.entries(changes);
+		entries.map(([field]) => `data = json_set(data, ?, json(?))`);
+		const assignments = [];
+		if (entries.length > 0) assignments.push(`data = ${entries.reduce((expression, _entry, index) => `json_set(${expression}, ?, json(?))`, "data")}`);
+		assignments.push("updated_at = ?");
+		assignments.push("revision = revision + 1");
+		const where = ["id = ?"];
+		const values = [];
+		for (const [field, value] of entries) values.push(jsonPath(field), serialize(value));
+		values.push((/* @__PURE__ */ new Date()).toISOString(), id);
+		if (condition?.expectedRevision !== void 0) {
+			where.push("revision = ?");
+			values.push(condition.expectedRevision);
+		}
+		if (condition?.expectedUpdatedAt !== void 0) {
+			where.push("updated_at = ?");
+			values.push(condition.expectedUpdatedAt.toISOString());
+		}
+		return {
+			sql: `UPDATE ${this.table(collection)}
+        SET ${assignments.join(", ")}
+        WHERE ${where.join(" AND ")}`,
+			values
+		};
+	}
+	async update(collection, id, changes, condition) {
+		const clean = cleanChanges(changes);
+		const statement = this.buildUpdate(collection, id, clean, condition);
+		const result = await this.run(statement.sql, statement.values);
+		if (getChanges(result) === 0) {
+			if (condition && await this.findById(collection, id)) throw new StorageConflictError();
+			return null;
+		}
+		return this.findById(collection, id);
+	}
+	async updateMany(collection, query, changes) {
+		validateQuery(query);
+		const clean = cleanChanges(changes);
+		const entries = Object.entries(clean);
+		const assignments = entries.length ? `data = ${entries.reduce((expression) => `json_set(${expression}, ?, json(?))`, "data")}, ` : "";
+		const values = [];
+		for (const [field, value] of entries) values.push(jsonPath(field), serialize(value));
+		values.push((/* @__PURE__ */ new Date()).toISOString());
+		const where = buildWhere(query.where);
+		values.push(...where.values);
+		const result = await this.run(`UPDATE ${this.table(collection)}
+       SET ${assignments}updated_at = ?, revision = revision + 1
+       WHERE ${where.sql}`, values);
+		return getChanges(result);
+	}
+	async delete(collection, id, condition) {
+		const where = ["id = ?"];
+		const values = [id];
+		if (condition?.expectedRevision !== void 0) {
+			where.push("revision = ?");
+			values.push(condition.expectedRevision);
+		}
+		if (condition?.expectedUpdatedAt !== void 0) {
+			where.push("updated_at = ?");
+			values.push(condition.expectedUpdatedAt.toISOString());
+		}
+		const result = await this.run(`DELETE FROM ${this.table(collection)}
+       WHERE ${where.join(" AND ")}`, values);
+		if (getChanges(result) > 0) return true;
+		if (condition && await this.findById(collection, id)) throw new StorageConflictError();
+		return false;
+	}
+	async deleteMany(collection, query) {
+		validateQuery(query);
+		const where = buildWhere(query.where);
+		const result = await this.run(`DELETE FROM ${this.table(collection)} WHERE ${where.sql}`, where.values);
+		return getChanges(result);
+	}
+	async exists(collection, query) {
+		validateQuery(query);
+		const where = buildWhere(query.where);
+		return await this.first(`SELECT 1 AS found FROM ${this.table(collection)}
+       WHERE ${where.sql} LIMIT 1`, where.values) !== null;
+	}
+	async count(collection, query = {}) {
+		validateQuery(query);
+		const where = buildWhere(query.where);
+		const result = await this.first(`SELECT COUNT(*) AS total FROM ${this.table(collection)}
+       WHERE ${where.sql}`, where.values);
+		return Number(result?.total ?? 0);
+	}
+	async atomicBatch(operations) {
+		const assertionTable = quoteIdentifier(`${this.prefix}atomic_assertions`);
+		await this.run(`
+      CREATE TABLE IF NOT EXISTS ${assertionTable} (
+        value INTEGER NOT NULL CHECK (value = 1)
+      )
+    `);
+		const statements = [];
+		const resultIndexes = [];
+		for (const operation of operations) {
+			const table = this.table(operation.collection);
+			if (operation.type !== "insert" && (operation.condition?.expectedRevision !== void 0 || operation.condition?.expectedUpdatedAt !== void 0)) {
+				const conditions = ["id = ?"];
+				const values = [operation.id];
+				if (operation.condition.expectedRevision !== void 0) {
+					conditions.push("revision = ?");
+					values.push(operation.condition.expectedRevision);
+				}
+				if (operation.condition.expectedUpdatedAt !== void 0) {
+					conditions.push("updated_at = ?");
+					values.push(operation.condition.expectedUpdatedAt.toISOString());
+				}
+				statements.push(this.prepare(`INSERT INTO ${assertionTable}(value)
+             SELECT CASE WHEN EXISTS (
+               SELECT 1 FROM ${table}
+               WHERE ${conditions.join(" AND ")}
+             ) THEN 1 ELSE 0 END`, values));
+				statements.push(this.prepare(`DELETE FROM ${assertionTable}`));
+			}
+			if (operation.type === "insert") {
+				const statement = this.insertStatement(operation.collection, operation.record);
+				statements.push(this.prepare(statement.sql, statement.values));
+				resultIndexes.push(statements.length - 1);
+				continue;
+			}
+			if (operation.type === "update") {
+				const statement = this.buildUpdate(operation.collection, operation.id, cleanChanges(operation.changes), operation.condition);
+				statements.push(this.prepare(statement.sql, statement.values));
+				resultIndexes.push(statements.length - 1);
+				continue;
+			}
+			const conditions = ["id = ?"];
+			const values = [operation.id];
+			if (operation.condition?.expectedRevision !== void 0) {
+				conditions.push("revision = ?");
+				values.push(operation.condition.expectedRevision);
+			}
+			if (operation.condition?.expectedUpdatedAt !== void 0) {
+				conditions.push("updated_at = ?");
+				values.push(operation.condition.expectedUpdatedAt.toISOString());
+			}
+			statements.push(this.prepare(`DELETE FROM ${table} WHERE ${conditions.join(" AND ")}`, values));
+			resultIndexes.push(statements.length - 1);
+		}
+		try {
+			const batchResults = await this.database.batch(statements);
+			const results = [];
+			for (const [index, operation] of operations.entries()) {
+				const resultIndex = resultIndexes[index];
+				const result = resultIndex === void 0 ? void 0 : batchResults[resultIndex];
+				if (!result) throw new StorageAtomicityError("D1 batch did not return a result for every operation.");
+				if (operation.type === "insert") {
+					const input = operation.record;
+					const inserted = await this.findById(operation.collection, input.id);
+					if (!inserted) throw new StorageAtomicityError("D1 batch committed but the inserted record could not be read.");
+					results.push({
+						type: "insert",
+						record: inserted
+					});
+					continue;
+				}
+				if (operation.type === "update") {
+					results.push({
+						type: "update",
+						record: await this.findById(operation.collection, operation.id)
+					});
+					continue;
+				}
+				results.push({
+					type: "delete",
+					deleted: getChanges(result) > 0
+				});
+			}
+			return { results };
+		} catch (error) {
+			if ((error instanceof Error ? error.message.toLowerCase() : "").includes("check constraint")) throw new StorageConflictError();
+			return mapD1Error(error);
+		}
+	}
+};
+export { D1StorageAdapter };
+
+//# sourceMappingURL=d1.adapter.js.map