@peerbit/indexer-sqlite3 1.2.26 → 1.2.27-a4bcfcf

package/src/engine.ts

@@ -30,6 +30,7 @@ import {
 	selectChildren,
 } from "./schema.js";
 import type { Database, Statement } from "./types.js";
+import { isFKError } from "./utils.js";
 
 const escapePathToSQLName = (path: string[]) => {
 	return path.map((x) => x.replace(/[^a-zA-Z0-9]/g, "_"));
@@ -40,6 +41,49 @@ const replaceStatementKey = (table: Table) => table.name + "_replicate";
 const resolveChildrenStatement = (table: Table) =>
 	table.name + "_resolve_children";
 
+type FKMode = "strict" | "race-tolerant";
+
+async function safeReset(stmt?: Statement) {
+	if (!stmt || !stmt.reset) return;
+	try {
+		await stmt.reset();
+	} catch (e) {
+		if (isFKError(e)) return; // swallow FK-reset noise
+		throw e;
+	}
+}
+
+async function runIgnoreFK(stmt: Statement, values: any[]) {
+	try {
+		await stmt.run(values);
+		await safeReset(stmt); // success path: reset safely
+		return;
+	} catch (e) {
+		if (isFKError(e)) {
+			await safeReset(stmt); // swallow FK + swallow reset error
+			return; // pretend no-op
+		}
+		// real error
+		await safeReset(stmt); // best effort
+		throw e;
+	}
+}
+
+async function getIgnoreFK(stmt: Statement, values: any[]) {
+	try {
+		const out = await stmt.get(values);
+		await safeReset(stmt); // success path
+		return out;
+	} catch (e) {
+		if (isFKError(e)) {
+			await safeReset(stmt); // swallow FK + reset error
+			return undefined;
+		}
+		await safeReset(stmt);
+		throw e;
+	}
+}
+
 export class SQLLiteIndex<T extends Record<string, any>>
 	implements Index<T, any>
 {
@@ -61,6 +105,7 @@ export class SQLLiteIndex<T extends Record<string, any>>
 
 	iteratorTimeout: number;
 	closed: boolean = true;
+	private fkMode: FKMode;
 
 	id: string;
 	constructor(
@@ -71,8 +116,9 @@ export class SQLLiteIndex<T extends Record<string, any>>
 			start?: () => Promise<void> | void;
 			stop?: () => Promise<void> | void;
 		},
-		options?: { iteratorTimeout?: number },
+		options?: { iteratorTimeout?: number; fkMode?: FKMode },
 	) {
+		this.fkMode = options?.fkMode || "race-tolerant";
 		this.closed = true;
 		this.id = uuid();
 		this.scopeString =
@@ -347,26 +393,33 @@ export class SQLLiteIndex<T extends Record<string, any>>
 		return insert(
 			async (values, table) => {
 				let preId = values[table.primaryIndex];
-
-				if (preId != null) {
-					const statement = this.properties.db.statements.get(
-						replaceStatementKey(table),
-					)!;
-					await statement.run(values);
-					await statement.reset?.();
-					return preId;
-				} else {
-					const statement = this.properties.db.statements.get(
-						putStatementKey(table),
-					)!;
-					const out = await statement.get(values);
-					await statement.reset?.();
-
-					// TODO types
-					if (out == null) {
-						return undefined;
+				let statement: Statement | undefined = undefined;
+				try {
+					if (preId != null) {
+						statement = this.properties.db.statements.get(
+							replaceStatementKey(table),
+						)!;
+						this.fkMode === "race-tolerant"
+							? await runIgnoreFK(statement, values)
+							: await statement.run(values);
+						return preId;
+					} else {
+						statement = this.properties.db.statements.get(
+							putStatementKey(table),
+						)!;
+						const out =
+							this.fkMode === "race-tolerant"
+								? await getIgnoreFK(statement, values)
+								: await statement.get(values);
+
+						// TODO types
+						if (out == null) {
+							return undefined;
+						}
+						return out[table.primary as string];
 					}
-					return out[table.primary as string];
+				} finally {
+					await statement?.reset?.();
 				}
 			},
 			value,
@@ -441,8 +494,6 @@ export class SQLLiteIndex<T extends Record<string, any>>
 
 			once = true;
 
-			/* 	console.log("----------------------")
-				console.log(sqlFetch); */
 			const allResults = await planningScope.perform(async () => {
 				const allResults: Record<string, any>[] = await stmt.all([
 					...bindable,
@@ -585,7 +636,14 @@ export class SQLLiteIndex<T extends Record<string, any>>
 
 				// TODO types
 				for (const result of results) {
-					ret.push(types.toId(result[table.primary as string]));
+					ret.push(
+						types.toId(
+							convertFromSQLType(
+								result[table.primary as string],
+								table.primaryField!.from!.type,
+							),
+						),
+					);
 				}
 				once = true;
 			} catch (error) {

package/src/schema.ts

@@ -96,7 +96,7 @@ export class MissingFieldError extends Error {
 
 export const convertFromSQLType = (
 	value: boolean | bigint | string | number | Uint8Array,
-	type?: FieldType,
+	type: FieldType | undefined,
 ) => {
 	if (type === "bool") {
 		if (
@@ -341,7 +341,7 @@ export const getSQLFields = (
 							? sqlFields.find((field) => field.name === primary)
 							: undefined;
 					const parentPrimaryFieldName =
-						parentPrimaryField?.key || CHILD_TABLE_ID;
+						parentPrimaryField?.name || CHILD_TABLE_ID;
 					const parentPrimaryFieldType = parentPrimaryField
 						? parentPrimaryField.type
 						: "INTEGER";
@@ -707,7 +707,9 @@ export const insert = async (
 	tables: Map<string, Table>,
 	table: Table,
 	fields: Field[],
-	handleNestedCallback?: (cb: (parentId: any) => Promise<void>) => void,
+	handleNestedCallback?: (
+		cb: (parentId: any) => Promise<void>,
+	) => Promise<void> | void | number,
 	parentId: any = undefined,
 	index?: number,
 ): Promise<void> => {
@@ -843,7 +845,7 @@ export const insert = async (
 	// we need to know the id of the parent document to insert the foreign key correctly
 	for (const nested of nestedFields) {
 		const isOptional = nested.type instanceof OptionKind;
-		handleNestedCallback!((id) => handleNested(nested, isOptional, id));
+		await handleNestedCallback!((id) => handleNested(nested, isOptional, id));
 	}
 
 	const thisId = await insertFn(bindableValues, table);

package/src/sqlite3.browser.ts

@@ -236,7 +236,7 @@ const init = async (): Promise<DatabaseCreator> => {
 
 		const resolver = resolvers[message.id];
 		if (message.type === "error") {
-			resolver.reject(message.message);
+			resolver.reject(new Error(message.message));
 		} else if (message.type === "response") {
 			resolver.resolve(message.result);
 		}

package/src/sqlite3.wasm.ts

@@ -66,7 +66,29 @@ class Statement implements IStatement {
 	}
 
 	async reset() {
-		await this.statement.reset();
+		try {
+			await this.statement.reset(); // this returns the last rc
+		} catch (e: any) {
+			// sqlite3_reset() can surface the prior step/exec rc.
+			// The statement *is* reset; ignore benign codes.
+			const msg = e?.message || "";
+			const rc = e?.rc;
+			const code = e?.code;
+
+			const isFk =
+				code === "SQLITE_CONSTRAINT_FOREIGNKEY" ||
+				rc === 787 ||
+				msg.includes("SQLITE_CONSTRAINT_FOREIGNKEY") ||
+				msg.includes("FOREIGN KEY constraint failed");
+
+			const isBusy = code === "SQLITE_BUSY" || rc === 5; // optional
+
+			if (isFk || isBusy) {
+				return this as IStatement; // swallow; stmt is reset
+			}
+			// (keep throwing for other unexpected errors)
+			throw e;
+		}
 		return this as IStatement;
 	}
 

package/src/utils.ts

@@ -0,0 +1,9 @@
+export const isFKError = (e: any) => {
+	return (
+		e?.code === "SQLITE_CONSTRAINT_FOREIGNKEY" ||
+		e?.rc === 787 ||
+		(e?.message &&
+			(e.message.includes("SQLITE_CONSTRAINT_FOREIGNKEY") ||
+				e.message.includes("FOREIGN KEY constraint failed")))
+	);
+};