kitcn 0.23.0 → 0.25.0

package/dist/orm/migrations/index.d.ts

@@ -0,0 +1,3 @@
+import { C as MigrationTableName, D as defineMigrationSet, E as defineMigration, O as detectMigrationDrift, S as MigrationStep, T as buildMigrationPlan, _ as MigrationMigrateOne, a as MigrationCancelArgs, b as MigrationSet, c as MigrationStatusArgs, d as MigrationDefinition, f as MigrationDirection, g as MigrationManifestEntry, h as MigrationDriftIssue, l as createMigrationHandlers, m as MigrationDocContext, o as MigrationRunArgs, p as MigrationDoc, s as MigrationRunChunkArgs, u as MigrationAppliedState, v as MigrationPlan, w as MigrationWriteMode, x as MigrationStateMap, y as MigrationRunStatus } from "../../capabilities-Bem7xvGK.js";
+import { Ct as migrationCapability, dt as MIGRATION_STORAGE_TABLE_NAMES, ft as injectMigrationStorageTables, lt as MIGRATION_RUN_TABLE, mt as migrationStorageTables, pt as migrationExtension, ut as MIGRATION_STATE_TABLE } from "../../where-clause-compiler-mohWFiG0.js";
+export { MIGRATION_RUN_TABLE, MIGRATION_STATE_TABLE, MIGRATION_STORAGE_TABLE_NAMES, type MigrationAppliedState, type MigrationCancelArgs, type MigrationDefinition, type MigrationDirection, type MigrationDoc, type MigrationDocContext, type MigrationDriftIssue, type MigrationManifestEntry, type MigrationMigrateOne, type MigrationPlan, type MigrationRunArgs, type MigrationRunChunkArgs, type MigrationRunStatus, type MigrationSet, type MigrationStateMap, type MigrationStatusArgs, type MigrationStep, type MigrationTableName, type MigrationWriteMode, buildMigrationPlan, createMigrationHandlers, defineMigration, defineMigrationSet, detectMigrationDrift, injectMigrationStorageTables, migrationCapability, migrationExtension, migrationStorageTables };

package/dist/orm/migrations/index.js

@@ -0,0 +1,506 @@
+import { a as MIGRATION_RUN_TABLE, c as injectMigrationStorageTables, i as detectMigrationDrift, l as migrationExtension, n as defineMigration, o as MIGRATION_STATE_TABLE, r as defineMigrationSet, s as MIGRATION_STORAGE_TABLE_NAMES, t as buildMigrationPlan, u as migrationStorageTables } from "../../definitions-D9vhJ6OV.js";
+
+//#region src/orm/migrations/runtime.ts
+const DEFAULT_BATCH_SIZE = 128;
+function createMigrationHandlers(params) {
+	const { schema, migrations, getOrm, getChunkRef } = params;
+	const knownTables = new Set(Object.values(schema).map((tableConfig) => tableConfig.name));
+	const run = async (ctx, args = {}) => {
+		if (!migrations || migrations.migrations.length === 0) return {
+			status: "noop",
+			reason: "no_migrations_registered"
+		};
+		const direction = parseDirection(args.direction);
+		const dryRun = args.dryRun === true;
+		const allowDrift = args.allowDrift === true;
+		const restart = args.restart === true;
+		const batchSize = parseOptionalPositiveInteger(args.batchSize, "batchSize");
+		const steps = parseOptionalPositiveInteger(args.steps, "steps");
+		const to = parseOptionalString(args.to, "to");
+		const stateRows = await getAllStateRows(ctx.db);
+		const appliedState = toAppliedStateMap(stateRows);
+		const drift = detectMigrationDrift({
+			migrationSet: migrations,
+			appliedState
+		});
+		if (drift.length > 0 && !allowDrift) return {
+			status: "drift_blocked",
+			direction,
+			drift
+		};
+		const plan = buildMigrationPlan({
+			direction,
+			migrationSet: migrations,
+			appliedState,
+			steps,
+			to
+		});
+		if (plan.migrations.length === 0) return {
+			status: "noop",
+			direction,
+			drift,
+			plan: []
+		};
+		for (const migration of plan.migrations) {
+			const step = getStepForDirection(migration, direction);
+			if (!knownTables.has(step.table)) throw new Error(`Migration '${migration.id}' references unknown table '${step.table}'.`);
+		}
+		if (dryRun) return {
+			status: "dry_run",
+			direction,
+			drift,
+			plan: plan.migrations.map((migration) => migration.id)
+		};
+		const activeRun = await getActiveRun(ctx.db);
+		if (activeRun) return {
+			status: "running",
+			runId: activeRun.runId
+		};
+		const now = Date.now();
+		const runId = createRunId(now);
+		await ctx.db.insert(MIGRATION_RUN_TABLE, {
+			runId,
+			direction,
+			status: "running",
+			dryRun: false,
+			allowDrift,
+			migrationIds: plan.migrations.map((migration) => migration.id),
+			currentIndex: 0,
+			startedAt: now,
+			updatedAt: now,
+			cancelRequested: false
+		});
+		const stateById = new Map(stateRows.map((row) => [row.migrationId, row]));
+		for (const migration of plan.migrations) {
+			const writeMode = getStepForDirection(migration, direction).writeMode ?? "safe_bypass";
+			const existing = stateById.get(migration.id);
+			const resetProgress = restart || existing?.direction !== direction;
+			if (existing) await ctx.db.patch(existing._id, cleanUndefined({
+				checksum: migration.checksum,
+				status: "pending",
+				direction,
+				runId,
+				cursor: resetProgress ? null : existing.cursor ?? null,
+				processed: resetProgress ? 0 : existing.processed ?? 0,
+				startedAt: now,
+				updatedAt: now,
+				completedAt: null,
+				lastError: null,
+				writeMode
+			}));
+			else await ctx.db.insert(MIGRATION_STATE_TABLE, {
+				migrationId: migration.id,
+				checksum: migration.checksum,
+				applied: direction === "down",
+				status: "pending",
+				direction,
+				runId,
+				cursor: null,
+				processed: 0,
+				startedAt: now,
+				updatedAt: now,
+				completedAt: null,
+				lastError: null,
+				writeMode
+			});
+		}
+		if (ctx.scheduler) {
+			const chunkRef = getChunkRef();
+			if (chunkRef) {
+				const chunkArgs = { runId };
+				if (batchSize !== void 0) chunkArgs.batchSize = batchSize;
+				await ctx.scheduler.runAfter(0, chunkRef, chunkArgs);
+				return {
+					status: "running",
+					direction,
+					runId,
+					plan: plan.migrations.map((migration) => migration.id)
+				};
+			}
+		}
+		const inlineResult = await chunk(ctx, {
+			runId,
+			batchSize
+		});
+		return {
+			status: "running",
+			direction,
+			runId,
+			plan: plan.migrations.map((migration) => migration.id),
+			inlineResult
+		};
+	};
+	const chunk = async (ctx, args) => {
+		const runId = parseRequiredString(args.runId, "runId");
+		const batchSize = parseOptionalPositiveInteger(args.batchSize, "batchSize");
+		const runRow = await getRunById(ctx.db, runId);
+		if (!runRow) return {
+			status: "missing",
+			runId
+		};
+		if (runRow.status !== "running") return {
+			status: runRow.status,
+			runId
+		};
+		if (runRow.cancelRequested) {
+			await markRunCanceled(ctx.db, runRow);
+			return {
+				status: "canceled",
+				runId
+			};
+		}
+		const migrationId = runRow.migrationIds[runRow.currentIndex];
+		if (!migrationId) {
+			await markRunCompleted(ctx.db, runRow);
+			return {
+				status: "completed",
+				runId
+			};
+		}
+		const migration = migrations?.byId[migrationId];
+		if (!migration) {
+			await markRunFailed(ctx.db, runRow, `Migration '${migrationId}' is missing from registry.`);
+			return {
+				status: "failed",
+				runId
+			};
+		}
+		const direction = parseDirection(runRow.direction);
+		const step = getStepForDirection(migration, direction);
+		const resolvedBatchSize = batchSize ?? step.batchSize ?? DEFAULT_BATCH_SIZE;
+		const stateRow = await getOrCreateStateRow(ctx.db, migration, direction, step);
+		const cursor = stateRow.cursor ?? null;
+		try {
+			const page = await ctx.db.query(step.table).paginate({
+				cursor,
+				numItems: resolvedBatchSize
+			});
+			const docs = Array.isArray(page?.page) ? page.page : [];
+			const orm = getOrm(ctx);
+			const writeMode = step.writeMode ?? "safe_bypass";
+			let processedInBatch = 0;
+			for (const doc of docs) {
+				const migrationCtxBase = {
+					db: ctx.db,
+					migrationId,
+					runId,
+					direction,
+					dryRun: false,
+					writeMode
+				};
+				const result = await runWithWriteMode(orm, writeMode, (resolvedOrm) => step.migrateOne({
+					...migrationCtxBase,
+					orm: resolvedOrm
+				}, doc));
+				if (isPatchPayload(result) && hasDocId(doc)) await ctx.db.patch(doc._id, result);
+				processedInBatch += 1;
+			}
+			const now = Date.now();
+			const isDone = Boolean(page?.isDone);
+			const nextCursor = isDone ? null : page?.continueCursor ?? null;
+			const nextProcessed = (stateRow.processed ?? 0) + processedInBatch;
+			if (isDone) {
+				await ctx.db.patch(stateRow._id, cleanUndefined({
+					status: "completed",
+					applied: direction === "up",
+					cursor: null,
+					processed: nextProcessed,
+					completedAt: now,
+					updatedAt: now,
+					lastError: null,
+					runId,
+					direction,
+					writeMode
+				}));
+				const nextIndex = runRow.currentIndex + 1;
+				const done = nextIndex >= runRow.migrationIds.length;
+				await ctx.db.patch(runRow._id, cleanUndefined({
+					currentIndex: nextIndex,
+					status: done ? "completed" : "running",
+					updatedAt: now,
+					completedAt: done ? now : null,
+					lastError: null
+				}));
+				if (!done && ctx.scheduler) {
+					const chunkRef = getChunkRef();
+					if (chunkRef) await ctx.scheduler.runAfter(0, chunkRef, {
+						runId,
+						batchSize: resolvedBatchSize
+					});
+				}
+				return {
+					status: done ? "completed" : "running",
+					runId,
+					migrationId,
+					processedInBatch,
+					processed: nextProcessed,
+					currentIndex: nextIndex,
+					total: runRow.migrationIds.length
+				};
+			}
+			await ctx.db.patch(stateRow._id, cleanUndefined({
+				status: "running",
+				cursor: nextCursor,
+				processed: nextProcessed,
+				updatedAt: now,
+				runId,
+				direction,
+				writeMode
+			}));
+			await ctx.db.patch(runRow._id, cleanUndefined({
+				status: "running",
+				updatedAt: now
+			}));
+			if (ctx.scheduler) {
+				const chunkRef = getChunkRef();
+				if (chunkRef) await ctx.scheduler.runAfter(0, chunkRef, {
+					runId,
+					batchSize: resolvedBatchSize
+				});
+			}
+			return {
+				status: "running",
+				runId,
+				migrationId,
+				processedInBatch,
+				processed: nextProcessed,
+				cursor: nextCursor
+			};
+		} catch (error) {
+			const message = error.message || String(error);
+			await ctx.db.patch(stateRow._id, cleanUndefined({
+				status: "failed",
+				lastError: message,
+				updatedAt: Date.now()
+			}));
+			await markRunFailed(ctx.db, runRow, message);
+			return {
+				status: "failed",
+				runId,
+				migrationId,
+				error: message
+			};
+		}
+	};
+	const status = async (ctx, args = {}) => {
+		if (!migrations) return {
+			status: "noop",
+			reason: "no_migrations_registered"
+		};
+		const limit = parseOptionalPositiveInteger(args.limit, "limit") ?? 25;
+		const runId = parseOptionalString(args.runId, "runId");
+		const stateRows = await getAllStateRows(ctx.db);
+		const sortedRuns = [...await getAllRunRows(ctx.db)].sort((left, right) => right.startedAt - left.startedAt);
+		const selectedRuns = runId ? sortedRuns.filter((entry) => entry.runId === runId).slice(0, 1) : sortedRuns.slice(0, limit);
+		const activeRun = sortedRuns.find((entry) => entry.status === "running") ?? null;
+		const appliedState = toAppliedStateMap(stateRows);
+		const drift = detectMigrationDrift({
+			migrationSet: migrations,
+			appliedState
+		});
+		const pendingUp = buildMigrationPlan({
+			direction: "up",
+			migrationSet: migrations,
+			appliedState
+		});
+		return {
+			status: activeRun ? "running" : "idle",
+			activeRun,
+			runs: selectedRuns,
+			migrations: stateRows.map((row) => ({
+				migrationId: row.migrationId,
+				checksum: row.checksum,
+				applied: row.applied,
+				status: row.status,
+				direction: row.direction ?? null,
+				runId: row.runId ?? null,
+				cursor: row.cursor ?? null,
+				processed: row.processed,
+				updatedAt: row.updatedAt,
+				startedAt: row.startedAt ?? null,
+				completedAt: row.completedAt ?? null,
+				lastError: row.lastError ?? null,
+				writeMode: row.writeMode
+			})),
+			pending: pendingUp.migrations.map((migration) => migration.id),
+			drift
+		};
+	};
+	const cancel = async (ctx, args = {}) => {
+		if (!migrations) return {
+			status: "noop",
+			reason: "no_migrations_registered"
+		};
+		const runId = parseOptionalString(args.runId, "runId");
+		const runRow = runId ? await getRunById(ctx.db, runId) : await getActiveRun(ctx.db);
+		if (!runRow) return {
+			status: "noop",
+			reason: "no_active_run"
+		};
+		if (runRow.status !== "running") return {
+			status: "noop",
+			reason: "run_not_running",
+			runId: runRow.runId,
+			runStatus: runRow.status
+		};
+		const now = Date.now();
+		await ctx.db.patch(runRow._id, cleanUndefined({
+			cancelRequested: true,
+			updatedAt: now
+		}));
+		if (!(ctx.scheduler ? getChunkRef() : void 0)) {
+			await markRunCanceled(ctx.db, runRow);
+			return {
+				status: "canceled",
+				runId: runRow.runId
+			};
+		}
+		return {
+			status: "cancel_requested",
+			runId: runRow.runId
+		};
+	};
+	return {
+		run,
+		chunk,
+		status,
+		cancel
+	};
+}
+function getStepForDirection(migration, direction) {
+	if (direction === "up") return migration.up;
+	if (!migration.down) throw new Error(`Migration '${migration.id}' is missing down migration.`);
+	return migration.down;
+}
+function createRunId(now) {
+	return `mr_${now}_${Math.random().toString(36).slice(2, 10)}`;
+}
+function parseDirection(value) {
+	if (value === void 0 || value === null) return "up";
+	if (value === "up" || value === "down") return value;
+	throw new Error("Migration direction must be either 'up' or 'down'.");
+}
+function parseOptionalPositiveInteger(value, fieldName) {
+	if (value === void 0 || value === null) return;
+	if (typeof value !== "number" || !Number.isInteger(value) || value < 1) throw new Error(`Migration ${fieldName} must be a positive integer.`);
+	return value;
+}
+function parseOptionalString(value, fieldName) {
+	if (value === void 0 || value === null) return;
+	if (typeof value !== "string" || value.length === 0) throw new Error(`Migration ${fieldName} must be a non-empty string.`);
+	return value;
+}
+function parseRequiredString(value, fieldName) {
+	const parsed = parseOptionalString(value, fieldName);
+	if (!parsed) throw new Error(`Migration ${fieldName} is required.`);
+	return parsed;
+}
+function toAppliedStateMap(stateRows) {
+	const entries = {};
+	for (const row of stateRows) entries[row.migrationId] = {
+		applied: row.applied,
+		checksum: row.checksum,
+		cursor: row.cursor ?? null,
+		processed: row.processed
+	};
+	return entries;
+}
+async function getAllStateRows(db) {
+	return await db.query(MIGRATION_STATE_TABLE).collect();
+}
+async function getAllRunRows(db) {
+	return await db.query(MIGRATION_RUN_TABLE).collect();
+}
+async function getRunById(db, runId) {
+	return await db.query(MIGRATION_RUN_TABLE).withIndex("by_run_id", (query) => query.eq("runId", runId)).first() ?? null;
+}
+async function getActiveRun(db) {
+	return await db.query(MIGRATION_RUN_TABLE).withIndex("by_status", (query) => query.eq("status", "running")).first() ?? null;
+}
+async function getOrCreateStateRow(db, migration, direction, step) {
+	const existing = await db.query(MIGRATION_STATE_TABLE).withIndex("by_migration_id", (query) => query.eq("migrationId", migration.id)).first();
+	if (existing) return existing;
+	const now = Date.now();
+	const stateId = await db.insert(MIGRATION_STATE_TABLE, {
+		migrationId: migration.id,
+		checksum: migration.checksum,
+		applied: direction === "down",
+		status: "pending",
+		direction,
+		runId: null,
+		cursor: null,
+		processed: 0,
+		startedAt: now,
+		updatedAt: now,
+		completedAt: null,
+		lastError: null,
+		writeMode: step.writeMode ?? "safe_bypass"
+	});
+	const created = await db.get(stateId);
+	if (!created) throw new Error(`Failed to create migration state row for '${migration.id}'.`);
+	return created;
+}
+async function markRunCompleted(db, runRow) {
+	const now = Date.now();
+	await db.patch(runRow._id, cleanUndefined({
+		status: "completed",
+		updatedAt: now,
+		completedAt: now,
+		cancelRequested: false,
+		lastError: null
+	}));
+}
+async function markRunCanceled(db, runRow) {
+	const now = Date.now();
+	await db.patch(runRow._id, cleanUndefined({
+		status: "canceled",
+		updatedAt: now,
+		completedAt: now,
+		cancelRequested: true
+	}));
+	for (const stateRow of await getAllStateRows(db)) if (stateRow.runId === runRow.runId && (stateRow.status === "running" || stateRow.status === "pending")) await db.patch(stateRow._id, cleanUndefined({
+		status: "canceled",
+		updatedAt: now
+	}));
+}
+async function markRunFailed(db, runRow, message) {
+	const now = Date.now();
+	await db.patch(runRow._id, cleanUndefined({
+		status: "failed",
+		updatedAt: now,
+		completedAt: now,
+		lastError: message
+	}));
+}
+async function runWithWriteMode(orm, writeMode, callback) {
+	if (writeMode === "normal") return await callback(orm);
+	return await orm.skipRules.withoutTriggers(async (noTriggersOrm) => {
+		return await callback(noTriggersOrm);
+	});
+}
+function isPatchPayload(value) {
+	return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function hasDocId(doc) {
+	return "_id" in doc && doc._id !== void 0 && doc._id !== null;
+}
+function cleanUndefined(value) {
+	return Object.fromEntries(Object.entries(value).filter(([, candidate]) => candidate !== void 0));
+}
+
+//#endregion
+//#region src/orm/migrations/capability.ts
+/**
+* Registers the migration runtime with `createOrm()`.
+*
+* Required by the migration handlers exposed through `orm.api()`. Importing
+* this pulls the migration runtime into the calling Convex module, so only
+* register it where it is actually used.
+*/
+const migrationCapability = () => ({
+	kind: "migrations",
+	value: { createMigrationHandlers }
+});
+
+//#endregion
+export { MIGRATION_RUN_TABLE, MIGRATION_STATE_TABLE, MIGRATION_STORAGE_TABLE_NAMES, buildMigrationPlan, createMigrationHandlers, defineMigration, defineMigrationSet, detectMigrationDrift, injectMigrationStorageTables, migrationCapability, migrationExtension, migrationStorageTables };

package/dist/plugins/index.d.ts

@@ -1,2 +1,2 @@
-import { a as PluginConfigureResolver, i as PluginConfigureInput, n as PluginApiScope, o as definePlugin, r as PluginConfigureContext, s as resolvePluginOptions, t as Plugin } from "../middleware-Br5zubu7.js";
+import { a as PluginConfigureResolver, i as PluginConfigureInput, n as PluginApiScope, o as definePlugin, r as PluginConfigureContext, s as resolvePluginOptions, t as Plugin } from "../middleware-CE_MC6Gi.js";
 export { type Plugin, type PluginApiScope, type PluginConfigureContext, type PluginConfigureInput, type PluginConfigureResolver, definePlugin, resolvePluginOptions };

package/dist/plugins/index.js

@@ -1,3 +1,3 @@
-import { n as resolvePluginOptions, t as definePlugin } from "../middleware-DUd1Sj39.js";
+import { n as resolvePluginOptions, t as definePlugin } from "../middleware-cJDRHTRY.js";
 
 export { definePlugin, resolvePluginOptions };

package/dist/{procedure-caller-DQxnLBS_.js → procedure-caller-DIzXfX2E.js}

@@ -1,5 +1,5 @@
-import { i as decodeWire, o as encodeWire } from "./transformer-yZuBWo8v.js";
-import { _ as CRPCError } from "./builder-CsxVc5xC.js";
+import { i as decodeWire, o as encodeWire } from "./transformer-D8wO-kEj.js";
+import { _ as CRPCError } from "./builder-1Vx-tEnS.js";
 import { z } from "zod";
 
 //#region src/server/env.ts

package/dist/{procedure-name-C55TynK3.d.ts → procedure-name-B09-cf1-.d.ts}

@@ -1,6 +1,6 @@
-import { t as VRequired } from "./validators-BhsByJeg.js";
-import { C as HttpProcedure, D as ProcedureMeta, R as getTransformer, S as HttpMethod, c as InferHttpInput, d as CRPCHttpRouter, j as DataTransformerOptions, l as InferHttpOutput, p as HttpRouterRecord, w as HttpProcedureBuilderDef, x as HttpHandlerOpts } from "./http-types-BoSDAh4Y.js";
-import { g as UnsetMarker, i as IntersectIfDefined, o as MiddlewareBuilder, p as Overwrite$1, s as MiddlewareFunction, t as AnyMiddleware } from "./types-CnTpHR1F.js";
+import { t as VRequired } from "./validators-V4eM2-Jg.js";
+import { A as HttpProcedureBuilderDef, D as HttpHandlerOpts, L as DataTransformerOptions, N as ProcedureMeta, O as HttpMethod, W as getTransformer, _ as CRPCHttpRouter, f as InferHttpInput, k as HttpProcedure, p as InferHttpOutput, y as HttpRouterRecord } from "./http-types-90mapMP9.js";
+import { g as UnsetMarker, i as IntersectIfDefined, o as MiddlewareBuilder, p as Overwrite$1, s as MiddlewareFunction, t as AnyMiddleware } from "./types-eNzQmbqM.js";
 import { ConvexError, GenericId, GenericValidator, ObjectType, OptionalProperty, PropertyValidators, VAny, VArray, VBoolean, VBytes, VFloat64, VId, VInt64, VLiteral, VNull, VObject, VOptional, VRecord, VString, VUnion, Validator, Value as Value$1 } from "convex/values";
 import { ActionBuilder, ArgsArrayToObject, DefaultFunctionArgs, FunctionReference, FunctionReturnType, FunctionVisibility, GenericActionCtx, GenericDataModel, GenericMutationCtx, GenericQueryCtx, MutationBuilder, QueryBuilder, RegisteredAction, RegisteredMutation, RegisteredQuery, TableNamesInDataModel } from "convex/server";
 import { z } from "zod";