dineway 0.1.9 → 0.1.12

package/dist/fts-manager-B1pTNEG_.mjs

@@ -0,0 +1,297 @@
+import { t as __exportAll } from "./chunk-ClPoSABd.mjs";
+import { t as validateIdentifier } from "./validate-VPnKoIzW.mjs";
+import { a as isSqlite, c as tableExists } from "./dialect-helpers-DhTzaUxP.mjs";
+import { sql } from "kysely";
+
+//#region src/search/fts-manager.ts
+var fts_manager_exports = /* @__PURE__ */ __exportAll({ FTSManager: () => FTSManager });
+/**
+* FTS5 Manager
+*
+* Handles creation, deletion, and management of FTS5 virtual tables
+* for full-text search on content collections.
+*/
+var FTSManager = class {
+	constructor(db) {
+		this.db = db;
+	}
+	/**
+	* Validate a collection slug and its searchable field names.
+	* Must be called before any raw SQL interpolation.
+	*/
+	validateInputs(collectionSlug, searchableFields) {
+		validateIdentifier(collectionSlug, "collection slug");
+		if (searchableFields) for (const field of searchableFields) validateIdentifier(field, "searchable field name");
+	}
+	/**
+	* Get the FTS table name for a collection
+	* Uses _dineway_ prefix to clearly mark as internal/system table
+	*/
+	getFtsTableName(collectionSlug) {
+		validateIdentifier(collectionSlug, "collection slug");
+		return `_dineway_fts_${collectionSlug}`;
+	}
+	/**
+	* Get the content table name for a collection
+	*/
+	getContentTableName(collectionSlug) {
+		validateIdentifier(collectionSlug, "collection slug");
+		return `ec_${collectionSlug}`;
+	}
+	/**
+	* Check if an FTS table exists for a collection
+	*/
+	async ftsTableExists(collectionSlug) {
+		const ftsTable = this.getFtsTableName(collectionSlug);
+		return tableExists(this.db, ftsTable);
+	}
+	/**
+	* Create an FTS5 virtual table for a collection.
+	* FTS5 is SQLite-only; on other dialects this is a no-op.
+	*
+	* @param collectionSlug - The collection slug
+	* @param searchableFields - Array of field names to index
+	* @param weights - Optional field weights for ranking
+	*/
+	async createFtsTable(collectionSlug, searchableFields, _weights) {
+		if (!isSqlite(this.db)) return;
+		this.validateInputs(collectionSlug, searchableFields);
+		const ftsTable = this.getFtsTableName(collectionSlug);
+		const contentTable = this.getContentTableName(collectionSlug);
+		const columns = [
+			"id UNINDEXED",
+			"locale UNINDEXED",
+			...searchableFields
+		].join(", ");
+		await sql.raw(`
+			CREATE VIRTUAL TABLE IF NOT EXISTS "${ftsTable}" USING fts5(
+				${columns},
+				content='${contentTable}',
+				content_rowid='rowid',
+				tokenize='porter unicode61'
+			)
+		`).execute(this.db);
+		await this.createTriggers(collectionSlug, searchableFields);
+	}
+	/**
+	* Create triggers to keep FTS table in sync with content table.
+	*
+	* Insert and update triggers only add rows to the FTS index when
+	* `deleted_at IS NULL`. This keeps soft-deleted content out of the
+	* index and keeps repair counts aligned with searchable content.
+	*/
+	async createTriggers(collectionSlug, searchableFields) {
+		this.validateInputs(collectionSlug, searchableFields);
+		const ftsTable = this.getFtsTableName(collectionSlug);
+		const contentTable = this.getContentTableName(collectionSlug);
+		const fieldList = searchableFields.join(", ");
+		const newFieldList = searchableFields.map((f) => `NEW.${f}`).join(", ");
+		await sql.raw(`
+			CREATE TRIGGER IF NOT EXISTS "${ftsTable}_insert" 
+			AFTER INSERT ON "${contentTable}" 
+			WHEN NEW.deleted_at IS NULL
+			BEGIN
+				INSERT INTO "${ftsTable}"(rowid, id, locale, ${fieldList})
+				VALUES (NEW.rowid, NEW.id, NEW.locale, ${newFieldList});
+			END
+		`).execute(this.db);
+		await sql.raw(`
+			CREATE TRIGGER IF NOT EXISTS "${ftsTable}_update" 
+			AFTER UPDATE ON "${contentTable}" 
+			BEGIN
+				DELETE FROM "${ftsTable}" WHERE rowid = OLD.rowid;
+				INSERT INTO "${ftsTable}"(rowid, id, locale, ${fieldList})
+				SELECT NEW.rowid, NEW.id, NEW.locale, ${newFieldList}
+				WHERE NEW.deleted_at IS NULL;
+			END
+		`).execute(this.db);
+		await sql.raw(`
+			CREATE TRIGGER IF NOT EXISTS "${ftsTable}_delete" 
+			AFTER DELETE ON "${contentTable}" 
+			BEGIN
+				DELETE FROM "${ftsTable}" WHERE rowid = OLD.rowid;
+			END
+		`).execute(this.db);
+	}
+	/**
+	* Drop triggers for a collection
+	*/
+	async dropTriggers(collectionSlug) {
+		this.validateInputs(collectionSlug);
+		const ftsTable = this.getFtsTableName(collectionSlug);
+		await sql.raw(`DROP TRIGGER IF EXISTS "${ftsTable}_insert"`).execute(this.db);
+		await sql.raw(`DROP TRIGGER IF EXISTS "${ftsTable}_update"`).execute(this.db);
+		await sql.raw(`DROP TRIGGER IF EXISTS "${ftsTable}_delete"`).execute(this.db);
+	}
+	/**
+	* Drop the FTS table and triggers for a collection
+	*/
+	async dropFtsTable(collectionSlug) {
+		if (!isSqlite(this.db)) return;
+		this.validateInputs(collectionSlug);
+		const ftsTable = this.getFtsTableName(collectionSlug);
+		await this.dropTriggers(collectionSlug);
+		await sql.raw(`DROP TABLE IF EXISTS "${ftsTable}"`).execute(this.db);
+	}
+	/**
+	* Rebuild the FTS index for a collection
+	*
+	* This is useful after bulk imports or if the index gets out of sync.
+	*/
+	async rebuildIndex(collectionSlug, searchableFields, weights) {
+		if (!isSqlite(this.db)) return;
+		await this.dropFtsTable(collectionSlug);
+		await this.createFtsTable(collectionSlug, searchableFields, weights);
+		await this.populateFromContent(collectionSlug, searchableFields);
+	}
+	/**
+	* Populate the FTS table from existing content
+	*/
+	async populateFromContent(collectionSlug, searchableFields) {
+		if (!isSqlite(this.db)) return;
+		this.validateInputs(collectionSlug, searchableFields);
+		const ftsTable = this.getFtsTableName(collectionSlug);
+		const contentTable = this.getContentTableName(collectionSlug);
+		const fieldList = searchableFields.join(", ");
+		await sql.raw(`
+			INSERT INTO "${ftsTable}"(rowid, id, locale, ${fieldList})
+			SELECT rowid, id, locale, ${fieldList} FROM "${contentTable}"
+			WHERE deleted_at IS NULL
+		`).execute(this.db);
+	}
+	/**
+	* Get the search configuration for a collection
+	*/
+	async getSearchConfig(collectionSlug) {
+		const result = await this.db.selectFrom("_dineway_collections").select("search_config").where("slug", "=", collectionSlug).executeTakeFirst();
+		if (!result?.search_config) return null;
+		try {
+			const parsed = JSON.parse(result.search_config);
+			if (typeof parsed !== "object" || parsed === null || !("enabled" in parsed) || typeof parsed.enabled !== "boolean") return null;
+			const config = { enabled: parsed.enabled };
+			if ("weights" in parsed && typeof parsed.weights === "object" && parsed.weights !== null) {
+				const weights = {};
+				for (const [k, v] of Object.entries(parsed.weights)) if (typeof v === "number") weights[k] = v;
+				config.weights = weights;
+			}
+			return config;
+		} catch {
+			return null;
+		}
+	}
+	/**
+	* Update the search configuration for a collection
+	*/
+	async setSearchConfig(collectionSlug, config) {
+		await this.db.updateTable("_dineway_collections").set({ search_config: JSON.stringify(config) }).where("slug", "=", collectionSlug).execute();
+	}
+	/**
+	* Get searchable fields for a collection
+	*/
+	async getSearchableFields(collectionSlug) {
+		const collection = await this.db.selectFrom("_dineway_collections").select("id").where("slug", "=", collectionSlug).executeTakeFirst();
+		if (!collection) return [];
+		return (await this.db.selectFrom("_dineway_fields").select("slug").where("collection_id", "=", collection.id).where("searchable", "=", 1).execute()).map((f) => f.slug);
+	}
+	/**
+	* Enable search for a collection.
+	*
+	* Rebuilds from scratch to ensure stale tables or triggers do not survive
+	* repeated enablement.
+	*/
+	async enableSearch(collectionSlug, options) {
+		if (!isSqlite(this.db)) throw new Error("Full-text search is only available with SQLite databases");
+		const searchableFields = await this.getSearchableFields(collectionSlug);
+		if (searchableFields.length === 0) throw new Error(`No searchable fields defined for collection "${collectionSlug}". Mark at least one field as searchable before enabling search.`);
+		await this.rebuildIndex(collectionSlug, searchableFields, options?.weights);
+		await this.setSearchConfig(collectionSlug, {
+			enabled: true,
+			weights: options?.weights
+		});
+	}
+	/**
+	* Disable search for a collection
+	*
+	* Drops the FTS table and triggers.
+	*/
+	async disableSearch(collectionSlug) {
+		if (!isSqlite(this.db)) return;
+		const existing = await this.getSearchConfig(collectionSlug);
+		await this.dropFtsTable(collectionSlug);
+		await this.setSearchConfig(collectionSlug, {
+			enabled: false,
+			weights: existing?.weights
+		});
+	}
+	/**
+	* Get index statistics for a collection
+	*/
+	async getIndexStats(collectionSlug) {
+		if (!isSqlite(this.db)) return null;
+		this.validateInputs(collectionSlug);
+		const ftsDocsizeTable = `${this.getFtsTableName(collectionSlug)}_docsize`;
+		if (!await this.ftsTableExists(collectionSlug)) return null;
+		return { indexed: (await sql`
+			SELECT COUNT(*) as count FROM "${sql.raw(ftsDocsizeTable)}"
+		`.execute(this.db)).rows[0]?.count ?? 0 };
+	}
+	/**
+	* Verify FTS index integrity and rebuild if corrupted.
+	*
+	* Checks for row count mismatch between content table and FTS table.
+	*
+	* Returns true if the index was rebuilt, false if it was healthy.
+	*/
+	async verifyAndRepairIndex(collectionSlug) {
+		if (!isSqlite(this.db)) return false;
+		this.validateInputs(collectionSlug);
+		const ftsDocsizeTable = `${this.getFtsTableName(collectionSlug)}_docsize`;
+		const contentTable = this.getContentTableName(collectionSlug);
+		const fields = await this.getSearchableFields(collectionSlug);
+		const config = await this.getSearchConfig(collectionSlug);
+		if (!await this.ftsTableExists(collectionSlug)) {
+			if (!config?.enabled || fields.length === 0) return false;
+			console.warn(`FTS index for "${collectionSlug}" is missing. Rebuilding.`);
+			await this.rebuildIndex(collectionSlug, fields, config.weights);
+			return true;
+		}
+		const contentCount = await sql`
+			SELECT COUNT(*) as count FROM ${sql.ref(contentTable)}
+			WHERE deleted_at IS NULL
+		`.execute(this.db);
+		const ftsCount = await sql`
+			SELECT COUNT(*) as count FROM "${sql.raw(ftsDocsizeTable)}"
+		`.execute(this.db);
+		const contentRows = contentCount.rows[0]?.count ?? 0;
+		const ftsRows = ftsCount.rows[0]?.count ?? 0;
+		if (contentRows !== ftsRows) {
+			console.warn(`FTS index for "${collectionSlug}" has ${ftsRows} rows but content table has ${contentRows}. Rebuilding.`);
+			if (fields.length > 0) await this.rebuildIndex(collectionSlug, fields, config?.weights);
+			return true;
+		}
+		return false;
+	}
+	/**
+	* Verify and repair FTS indexes for all search-enabled collections.
+	*
+	* Intended to run at startup to auto-heal any corruption from
+	* previous process crashes.
+	*/
+	async verifyAndRepairAll() {
+		if (!isSqlite(this.db)) return 0;
+		const collections = await this.db.selectFrom("_dineway_collections").select("slug").where("search_config", "is not", null).execute();
+		let repaired = 0;
+		for (const { slug } of collections) {
+			if (!(await this.getSearchConfig(slug))?.enabled) continue;
+			try {
+				if (await this.verifyAndRepairIndex(slug)) repaired++;
+			} catch (error) {
+				console.error(`Failed to verify/repair FTS index for "${slug}":`, error);
+			}
+		}
+		return repaired;
+	}
+};
+
+//#endregion
+export { fts_manager_exports as n, FTSManager as t };

package/dist/hash-CDX7M0ze.mjs

@@ -0,0 +1,32 @@
+//#region src/utils/hash.ts
+/**
+* SHA-256 hash of a string, truncated to 16 hex chars (64 bits).
+* For cache invalidation / ETags — not for security.
+*/
+async function hashString(content) {
+	const buf = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(content));
+	return Array.from(new Uint8Array(buf).slice(0, 8), (b) => b.toString(16).padStart(2, "0")).join("");
+}
+/**
+* Compute content hash using Web Crypto API
+*
+* Uses SHA-1 which is the fastest option in SubtleCrypto.
+* SHA-1 is cryptographically weak but fine for content deduplication
+* where we only need to detect identical files, not resist attacks.
+*
+* Returns hex string prefixed with "sha1:" for future-proofing
+*/
+async function computeContentHash(content) {
+	let buf;
+	if (content instanceof ArrayBuffer) buf = content;
+	else {
+		buf = new ArrayBuffer(content.byteLength);
+		new Uint8Array(buf).set(content);
+	}
+	const hashBuffer = await crypto.subtle.digest("SHA-1", buf);
+	const hashArray = new Uint8Array(hashBuffer);
+	return `sha1:${Array.from(hashArray, (b) => b.toString(16).padStart(2, "0")).join("")}`;
+}
+
+//#endregion
+export { hashString as n, computeContentHash as t };

package/dist/hitl-requests-ChT32Ilo.mjs

@@ -0,0 +1,118 @@
+import { t as ExperimentalSiteContextWorkflowDisabledError } from "./experimental-workflows-C9X7yblQ.mjs";
+import { n as HitlRequestService } from "./site-context-WBxoD99D.mjs";
+
+//#region src/api/handlers/hitl-requests.ts
+const HITL_NOT_FOUND_RE = /not found/i;
+const HITL_INVALID_STATE_RE = /cannot resolve/i;
+async function handleHitlRequestList(db, actor, query) {
+	try {
+		return {
+			success: true,
+			data: await new HitlRequestService(db).list(actor, {
+				statuses: query.status ? [query.status] : void 0,
+				priority: query.priority,
+				actionType: query.actionType,
+				scope: query.scope,
+				targetRefType: query.targetRefType,
+				targetRefId: query.targetRefId,
+				limit: query.limit,
+				cursor: query.cursor
+			})
+		};
+	} catch (error) {
+		if (error instanceof ExperimentalSiteContextWorkflowDisabledError) return {
+			success: false,
+			error: {
+				code: "NOT_IMPLEMENTED",
+				message: error.message
+			}
+		};
+		console.error("HITL request list error:", error);
+		return {
+			success: false,
+			error: {
+				code: "WORKFLOW_HITL_LIST_ERROR",
+				message: "Failed to list HITL requests"
+			}
+		};
+	}
+}
+async function handleHitlRequestGet(db, id, actor) {
+	try {
+		const item = await new HitlRequestService(db).get(id, actor);
+		if (!item) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: "HITL request not found"
+			}
+		};
+		return {
+			success: true,
+			data: { item }
+		};
+	} catch (error) {
+		if (error instanceof ExperimentalSiteContextWorkflowDisabledError) return {
+			success: false,
+			error: {
+				code: "NOT_IMPLEMENTED",
+				message: error.message
+			}
+		};
+		console.error("HITL request get error:", error);
+		return {
+			success: false,
+			error: {
+				code: "WORKFLOW_HITL_GET_ERROR",
+				message: "Failed to fetch HITL request"
+			}
+		};
+	}
+}
+async function handleHitlRequestResolve(db, id, input) {
+	try {
+		return {
+			success: true,
+			data: { item: await new HitlRequestService(db).resolve({
+				id,
+				actor: input.actor,
+				decision: input.decision,
+				reviewNote: input.reviewNote
+			}) }
+		};
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Failed to resolve HITL request";
+		if (error instanceof ExperimentalSiteContextWorkflowDisabledError) return {
+			success: false,
+			error: {
+				code: "NOT_IMPLEMENTED",
+				message: error.message
+			}
+		};
+		console.error("HITL request resolve error:", error);
+		if (HITL_NOT_FOUND_RE.test(message)) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: "HITL request not found"
+			}
+		};
+		if (HITL_INVALID_STATE_RE.test(message)) return {
+			success: false,
+			error: {
+				code: "INVALID_STATE",
+				message: "HITL request is already resolved"
+			}
+		};
+		return {
+			success: false,
+			error: {
+				code: "WORKFLOW_HITL_RESOLVE_ERROR",
+				message: "Failed to resolve HITL request"
+			}
+		};
+	}
+}
+
+//#endregion
+export { handleHitlRequestList as n, handleHitlRequestResolve as r, handleHitlRequestGet as t };

package/dist/hitl-route-helpers-CSit54Ru.mjs

@@ -0,0 +1,96 @@
+import { t as apiError } from "./error-BMUPwxgx.mjs";
+import { t as ExperimentalSiteContextWorkflowDisabledError } from "./experimental-workflows-C9X7yblQ.mjs";
+import { t as WorkflowHitlCoordinator } from "./site-context-WBxoD99D.mjs";
+import { T as resolveActorIdentity, p as logSiteActivitySafely } from "./activity-events-B4wp7CrU.mjs";
+import { Role } from "@dineway-ai/auth";
+
+//#region src/api/hitl-route-helpers.ts
+function resolveHitlRouteActor(locals) {
+	const identity = resolveActorIdentity(toActorLocals(locals));
+	return {
+		identity,
+		access: {
+			actorType: identity.actorType,
+			actorId: identity.actorId,
+			authMetadata: identity.authMetadata,
+			userRole: locals.user?.role ?? Role.SUBSCRIBER
+		}
+	};
+}
+async function ensureWorkflowHitlRouteRequest(db, locals, action) {
+	const actor = resolveHitlRouteActor(locals);
+	let ensured;
+	try {
+		ensured = await new WorkflowHitlCoordinator(db).ensureRequest({
+			actor: actor.access,
+			action
+		});
+	} catch (error) {
+		if (error instanceof ExperimentalSiteContextWorkflowDisabledError) return {
+			status: "disabled",
+			message: error.message
+		};
+		throw error;
+	}
+	if (!ensured.created) return {
+		status: "ready",
+		...ensured
+	};
+	await logSiteActivitySafely(db, toActorLocals(locals), {
+		actionType: "hitl.submitted",
+		subjectType: "hitl_request",
+		subjectId: ensured.request.id,
+		scope: ensured.request.scope,
+		summary: `Submitted HITL request for ${ensured.request.actionType}`,
+		detail: {
+			actionType: ensured.request.actionType,
+			targetRefType: ensured.request.targetRefType,
+			targetRefId: ensured.request.targetRefId,
+			priority: ensured.request.priority,
+			riskReason: ensured.request.riskReason
+		}
+	});
+	return {
+		status: "ready",
+		...ensured
+	};
+}
+function hitlRequiredRouteError(decision, input) {
+	if (input.status === "disabled") return apiError("NOT_IMPLEMENTED", input.message, 501, {
+		status: "workflow_hitl_disabled",
+		reason: "workflow_hitl_disabled"
+	});
+	return apiError("HITL_REQUIRED", decision.message, 409, {
+		status: "hitl_required",
+		reason: decision.reason,
+		created: input.created,
+		request: input.request
+	});
+}
+async function logHitlRouteActivity(db, locals, input) {
+	await logSiteActivitySafely(db, toActorLocals(locals), {
+		actionType: input.actionType,
+		subjectType: "hitl_request",
+		subjectId: input.item.id,
+		scope: input.item.scope,
+		summary: `${input.actionType === "hitl.approved" ? "Approved" : "Rejected"} HITL request ${input.item.id}`,
+		detail: {
+			actionType: input.item.actionType,
+			targetRefType: input.item.targetRefType,
+			targetRefId: input.item.targetRefId,
+			priority: input.item.priority,
+			riskReason: input.item.riskReason,
+			reviewNote: input.item.reviewNote
+		}
+	});
+}
+function toActorLocals(locals) {
+	return {
+		user: locals.user ? { id: locals.user.id } : null,
+		tokenScopes: locals.tokenScopes,
+		authToken: locals.authToken
+	};
+}
+
+//#endregion
+export { resolveHitlRouteActor as i, hitlRequiredRouteError as n, logHitlRouteActivity as r, ensureWorkflowHitlRouteRequest as t };