@hot-updater/server 0.30.11 → 0.31.0

package/dist/node_modules/.pnpm/fumadb@0.2.2_drizzle-orm@0.44.7_@cloudflare_workers-types@4.20260313.1_@electric-sql_pg_c72c8c754becd21f6d6662e8fbd28e7f/node_modules/fumadb/dist/chunk-ZOCGSAWS.mjs

@@ -0,0 +1,212 @@
+//#region ../../node_modules/.pnpm/fumadb@0.2.2_drizzle-orm@0.44.7_@cloudflare+workers-types@4.20260313.1_@electric-sql+pg_c72c8c754becd21f6d6662e8fbd28e7f/node_modules/fumadb/dist/chunk-ZOCGSAWS.js
+async function checkForeignKeyOnInsert(orm, key, inserts) {
+	const ifMatchEntry = [];
+	function shouldSkipChecking(insert) {
+		for (const priorInsert of inserts) {
+			if (priorInsert === insert) break;
+			if (key.columns.every((col) => insert[col.ormName] === priorInsert[col.ormName])) return true;
+			if (key.table === key.referencedTable && key.columns.every((col, i) => insert[col.ormName] === priorInsert[key.referencedColumns[i].ormName])) return true;
+		}
+		return false;
+	}
+	for (const insert of inserts) {
+		if (shouldSkipChecking(insert)) continue;
+		const ifMatchColumn = [];
+		let containsNull = false;
+		for (let i = 0; i < key.columns.length; i++) {
+			const col = key.columns[i];
+			const referencedCol = key.referencedColumns[i];
+			if (insert[col.ormName] == null) {
+				containsNull = true;
+				break;
+			}
+			ifMatchColumn.push({
+				type: 2,
+				a: referencedCol,
+				operator: "=",
+				b: insert[col.ormName]
+			});
+		}
+		if (!containsNull) ifMatchEntry.push({
+			type: 0,
+			items: ifMatchColumn
+		});
+	}
+	if (ifMatchEntry.length === 0) return;
+	if (await orm.count(key.referencedTable, { where: {
+		type: 1,
+		items: ifMatchEntry
+	} }) < ifMatchEntry.length) errorForeignKey(key);
+}
+async function exists(orm, table, where) {
+	return await orm.findFirst(table, {
+		select: [table.getIdColumn().ormName],
+		where
+	}) !== null;
+}
+async function foreignKeyOnUpdate(orm, key, set, targets) {
+	const isAffected = {
+		type: 1,
+		items: []
+	};
+	if (!key.referencedColumns.some((col) => set[col.ormName] !== void 0)) return;
+	for (const target of targets) {
+		const condition = {
+			type: 0,
+			items: []
+		};
+		let containsNull = false;
+		for (let i = 0; i < key.columns.length; i++) {
+			const col = key.columns[i];
+			const referencedCol = key.referencedColumns[i];
+			if (target[referencedCol.ormName] === null) {
+				containsNull = true;
+				break;
+			}
+			condition.items.push({
+				type: 2,
+				a: col,
+				operator: "=",
+				b: target[referencedCol.ormName]
+			});
+		}
+		if (!containsNull) isAffected.items.push(condition);
+	}
+	if (isAffected.items.length === 0) return;
+	if (key.onUpdate === "RESTRICT") {
+		if (await exists(orm, key.table, isAffected)) errorForeignKey(key);
+		return;
+	}
+	const mappedSet = {};
+	for (let i = 0; i < key.columns.length; i++) {
+		const col = key.columns[i].ormName;
+		const referencedCol = key.referencedColumns[i].ormName;
+		mappedSet[col] = key.onUpdate === "CASCADE" ? set[referencedCol] : null;
+	}
+	await orm.updateMany(key.table, {
+		where: isAffected,
+		set: mappedSet
+	});
+}
+function createSoftForeignKey(schema, { generateInsertValuesDefault, ...orm }) {
+	const childForeignKeys = /* @__PURE__ */ new Map();
+	for (const table of Object.values(schema.tables)) for (const key of table.foreignKeys) {
+		const name = key.referencedTable.ormName;
+		const list = childForeignKeys.get(name) ?? [];
+		list.push(key);
+		childForeignKeys.set(name, list);
+	}
+	if (!orm.transaction) throw new Error("native `transaction` required for soft foreign key.");
+	return {
+		...orm,
+		async updateMany(table, { set, where }) {
+			const foreignKeys = childForeignKeys.get(table.ormName);
+			if (!foreignKeys) return orm.updateMany(table, {
+				set,
+				where
+			});
+			const idColumnName = table.getIdColumn().ormName;
+			const targets = await orm.findMany(table, {
+				select: true,
+				where
+			});
+			await orm.transaction?.(async (tx) => {
+				for (const key of foreignKeys) await foreignKeyOnUpdate(tx.internal, key, set, targets);
+				await orm.updateMany(table, {
+					set,
+					where: {
+						type: 2,
+						a: table.columns[idColumnName],
+						operator: "in",
+						b: targets.map((target) => target[idColumnName])
+					}
+				});
+			});
+		},
+		async upsert(table, v) {
+			const target = await orm.findFirst(table, {
+				select: true,
+				where: v.where
+			});
+			if (target === null) await this.createMany(table, [v.create]);
+			else {
+				const idColumn = table.getIdColumn();
+				await this.updateMany(table, {
+					set: v.update,
+					where: {
+						type: 2,
+						a: table.columns[idColumn.ormName],
+						operator: "=",
+						b: target[idColumn.ormName]
+					}
+				});
+			}
+		},
+		async create(table, values) {
+			values = generateInsertValuesDefault(table, values);
+			await Promise.all(table.foreignKeys.map((key) => checkForeignKeyOnInsert(this, key, [values])));
+			return orm.create(table, values);
+		},
+		async createMany(table, values) {
+			values = values.map((value) => generateInsertValuesDefault(table, value));
+			await Promise.all(table.foreignKeys.map((key) => checkForeignKeyOnInsert(this, key, values)));
+			return orm.createMany(table, values);
+		},
+		async deleteMany(table, v) {
+			const foreignKeys = childForeignKeys.get(table.ormName);
+			if (!foreignKeys) return orm.deleteMany(table, v);
+			const targets = await orm.findMany(table, {
+				select: true,
+				where: v.where
+			});
+			for (const key of foreignKeys) {
+				const isAffected = {
+					type: 1,
+					items: []
+				};
+				for (const target of targets) {
+					const isReferencingTarget = {
+						type: 0,
+						items: []
+					};
+					let containsNull = false;
+					for (let i = 0; i < key.columns.length; i++) {
+						const targetValue = target[key.referencedColumns[i].ormName];
+						if (targetValue === null) {
+							containsNull = true;
+							break;
+						}
+						isReferencingTarget.items.push({
+							type: 2,
+							a: key.columns[i],
+							operator: "=",
+							b: targetValue
+						});
+					}
+					if (!containsNull) isAffected.items.push(isReferencingTarget);
+				}
+				if (key.onDelete === "CASCADE") await orm.deleteMany(key.table, { where: isAffected });
+				else if (key.onDelete === "SET NULL") {
+					const set = {};
+					for (const col of key.columns) set[col.ormName] = null;
+					await orm.updateMany(key.table, {
+						set,
+						where: isAffected
+					});
+				} else if (await exists(this, key.table, isAffected)) errorForeignKey(key);
+			}
+			const idColumnName = table.getIdColumn().ormName;
+			return orm.deleteMany(table, { where: {
+				type: 2,
+				a: table.columns[idColumnName],
+				operator: "in",
+				b: targets.map((target) => target[idColumnName])
+			} });
+		}
+	};
+}
+function errorForeignKey(key) {
+	throw new Error(`foreign constraint failed ${key.name}`);
+}
+//#endregion
+export { checkForeignKeyOnInsert, createSoftForeignKey };

package/dist/node_modules/.pnpm/fumadb@0.2.2_drizzle-orm@0.44.7_@cloudflare_workers-types@4.20260313.1_@electric-sql_pg_c72c8c754becd21f6d6662e8fbd28e7f/node_modules/fumadb/dist/create-tg0451Y_.d.cts

@@ -0,0 +1,285 @@
+//#region ../../node_modules/.pnpm/fumadb@0.2.2_drizzle-orm@0.44.7_@cloudflare+workers-types@4.20260313.1_@electric-sql+pg_c72c8c754becd21f6d6662e8fbd28e7f/node_modules/fumadb/dist/create-tg0451Y_.d.ts
+type AnySchema = Schema<string, Record<string, AnyTable>>;
+type AnyRelation = Relation;
+type AnyTable = Table;
+type AnyColumn = Column<keyof TypeMap, unknown, unknown> | IdColumn<IdColumnType, unknown, unknown>;
+type ForeignKeyAction = "RESTRICT" | "CASCADE" | "SET NULL";
+interface NameVariants {
+  sql: string;
+  drizzle: string;
+  prisma: string;
+  convex: string;
+  mongodb: string;
+}
+interface ForeignKey {
+  name: string;
+  table: AnyTable;
+  columns: AnyColumn[];
+  referencedTable: AnyTable;
+  referencedColumns: AnyColumn[];
+  onUpdate: ForeignKeyAction;
+  onDelete: ForeignKeyAction;
+}
+interface UniqueConstraint {
+  name: string;
+  columns: AnyColumn[];
+}
+interface BaseRelation<Type extends RelationType = RelationType, T extends AnyTable = AnyTable> {
+  /**
+   * The relation id shared between implied/implying relation
+   */
+  id: string;
+  name: string;
+  type: Type;
+  table: T;
+  referencer: AnyTable;
+  on: [string, string][];
+}
+interface ImplicitRelation<Type extends RelationType = RelationType, T extends AnyTable = AnyTable> extends BaseRelation<Type, T> {
+  implied: true;
+  readonly impliedBy: ExplicitRelation;
+}
+interface ExplicitRelation<Type extends RelationType = RelationType, T extends AnyTable = AnyTable> extends BaseRelation<Type, T> {
+  implied: false;
+  implying: ImplicitRelation | undefined;
+  foreignKey?: ForeignKey;
+}
+type Relation<Type extends RelationType = RelationType, T extends AnyTable = AnyTable> = ImplicitRelation<Type, T> | ExplicitRelation<Type, T>;
+interface Table<Columns extends Record<string, AnyColumn> = Record<string, AnyColumn>, Relations extends Record<string, AnyRelation> = Record<string, AnyRelation>> {
+  names: NameVariants;
+  ormName: string;
+  columns: Columns;
+  relations: Relations;
+  foreignKeys: ForeignKey[];
+  /**
+   * @param level default to 'all'
+   */
+  getUniqueConstraints: (level?: "table" | "column" | "all") => UniqueConstraint[];
+  /**
+   * @param name - name
+   * @param type - default to "sql"
+   */
+  getColumnByName: (name: string, type?: keyof NameVariants) => AnyColumn | undefined;
+  getIdColumn: () => AnyColumn;
+  /**
+   * Add unique constraint to the fields, for consistency, duplicated null values are allowed.
+   */
+  unique: (name: string, columns: (keyof Columns)[]) => Table<Columns, Relations>;
+  clone: () => Table<Columns, Relations>;
+}
+type DefaultFunctionMap = {
+  date: "now";
+  timestamp: "now";
+  string: "auto";
+} & Record<`varchar(${number})`, "auto">;
+type DefaultFunction<Type extends keyof TypeMap> = (Type extends keyof DefaultFunctionMap ? DefaultFunctionMap[Type] : never) | (() => TypeMap[Type]);
+type IdColumnType = `varchar(${number})` | "uuid";
+type TypeMap = {
+  string: string;
+  bigint: bigint;
+  integer: number;
+  decimal: number;
+  bool: boolean;
+  json: unknown;
+  /**
+   * this follows the same specs as Prisma `Bytes` for consistency.
+   */
+  binary: Uint8Array;
+  date: Date;
+  timestamp: Date;
+  uuid: string;
+} & Record<`varchar(${number})`, string>;
+declare class Column<Type extends keyof TypeMap, In = unknown, Out = unknown> {
+  type: Type;
+  ormName: string;
+  isNullable: boolean;
+  isUnique: boolean;
+  default?: {
+    value: TypeMap[Type];
+  } | {
+    runtime: DefaultFunction<Type>;
+  };
+  table: AnyTable;
+  private initNames;
+  get names(): NameVariants;
+  set names(v: NameVariants);
+  constructor(type: Type, onInitNames: (ormName: string) => NameVariants);
+  nullable<T extends boolean = true>(nullable?: T): Column<Type, T extends true ? In | null : Exclude<In, null>, T extends true ? Out | null : Exclude<Out, null>>;
+  /**
+   * Add unique constraint to the field, for consistency, duplicated null values are allowed.
+   */
+  unique(unique?: boolean): this;
+  /**
+   * Generate default value on runtime
+   */
+  defaultTo$(fn: DefaultFunction<Type>): Column<Type, In | null, Out>;
+  /**
+   * Set a database-level default value
+   *
+   * For schemaless database, it's still generated on runtime
+   */
+  defaultTo(value: TypeMap[Type]): Column<Type, In | null, Out>;
+  clone(): Column<Type, unknown, unknown>;
+  getUniqueConstraintName(): string;
+  /**
+   * Generate default value for the column on runtime.
+   */
+  generateDefaultValue(): TypeMap[Type] | undefined;
+  get $in(): In;
+  get $out(): Out;
+}
+declare class IdColumn<Type extends IdColumnType = IdColumnType, In = unknown, Out = unknown> extends Column<Type, In, Out> {
+  id: boolean;
+  constructor(type: Type, onInitNames: (ormName: string) => NameVariants);
+  clone(): IdColumn<Type, unknown, unknown>;
+  defaultTo$(fn: DefaultFunction<Type>): IdColumn<Type, In | null, Out>;
+  defaultTo(value: TypeMap[Type]): IdColumn<Type, In | null, Out>;
+}
+type RelationType = "many" | "one";
+interface Schema<Version extends string = string, Tables extends Record<string, AnyTable> = Record<string, AnyTable>> {
+  /**
+   * @description The version of the schema, it should be a semantic version string.
+   */
+  version: Version;
+  tables: Tables;
+  up?: CustomMigrationFn;
+  down?: CustomMigrationFn;
+  clone: () => Schema<Version, Tables>;
+}
+type NameVariantsConfig = Record<string, Partial<NameVariants>>;
+type BuildNameVariants<Tables extends Record<string, AnyTable>> = { [K in keyof Tables as K extends string ? keyof Tables[K]["columns"] extends string ? `${K}.${keyof Tables[K]["columns"]}` : never : never]?: Partial<NameVariants> } & { [k in keyof Tables]?: Partial<NameVariants> };
+type NameVariantsBuilder<Schemas extends AnySchema[], Out> = {
+  (variants: BuildNameVariants<Schemas[number]["tables"]>): Out;
+  <Version extends Schemas[number]["version"]>(versions: Version[], variants: BuildNameVariants<Extract<Schemas[number], {
+    version: Version;
+  }>["tables"]>): Out;
+  /**
+   * Add prefix to table names.
+   *
+   * If true, use package's `namespace` as prefix.
+   */
+  prefix: (prefix: true | string) => Out;
+};
+interface ForeignKeyInfo {
+  name: string;
+  columns: string[];
+  referencedTable: string;
+  referencedColumns: string[];
+  onUpdate: "RESTRICT" | "CASCADE" | "SET NULL";
+  onDelete: "RESTRICT" | "CASCADE" | "SET NULL";
+}
+type MigrationOperation = TableOperation | {
+  type: "add-foreign-key";
+  table: string;
+  value: ForeignKeyInfo;
+} | {
+  type: "drop-foreign-key";
+  table: string;
+  name: string;
+} | {
+  type: "drop-unique-constraint";
+  table: string;
+  name: string;
+} | {
+  type: "add-unique-constraint";
+  table: string;
+  columns: string[];
+  name: string;
+} | CustomOperation;
+type CustomOperation = {
+  type: "custom";
+} & Record<string, unknown>;
+type TableOperation = {
+  type: "create-table";
+  value: AnyTable;
+} | {
+  type: "drop-table";
+  name: string;
+} | {
+  /**
+   * Not supported by FumaDB
+   * - update table's primary key
+   */
+  type: "update-table";
+  name: string;
+  value: ColumnOperation[];
+} | {
+  type: "rename-table";
+  from: string;
+  to: string;
+};
+type ColumnOperation = {
+  type: "rename-column";
+  from: string;
+  to: string;
+} | {
+  type: "drop-column";
+  name: string;
+} | {
+  /**
+   * Note: unique constraints are not created, please use dedicated operations like `add-unique-constraint` instead
+   */
+  type: "create-column";
+  value: AnyColumn;
+} | {
+  /**
+   * warning: Not supported by SQLite
+   */
+  type: "update-column";
+  name: string;
+  /**
+   * For databases like MySQL, it requires the full definition for any modify column statement.
+   * Hence, you need to specify the full information of your column here.
+   *
+   * Then, opt-in for in-detail modification for other databases that supports changing data type/nullable/default separately, such as PostgreSQL.
+   *
+   * Note: unique constraints are not updated, please use dedicated operations like `add-unique-constraint` instead
+   */
+  value: AnyColumn;
+  updateNullable: boolean;
+  updateDefault: boolean;
+  updateDataType: boolean;
+};
+type Awaitable<T> = T | Promise<T>;
+interface MigrationContext {
+  auto: () => Promise<MigrationOperation[]>;
+}
+type CustomMigrationFn = (context: MigrationContext) => Awaitable<MigrationOperation[]>;
+interface MigrateOptions {
+  /**
+   * Manage how migrations are generated.
+   *
+   * - `from-schema` (default): compare fumadb schemas
+   * - `from-database`: introspect & compare the database with schema
+   */
+  mode?: "from-schema" | "from-database";
+  /**
+   * Update internal settings, it's true by default.
+   * We don't recommend to disable it other than testing purposes.
+   */
+  updateSettings?: boolean;
+  /**
+   * Enable unsafe operations when auto-generating migration.
+   */
+  unsafe?: boolean;
+}
+interface MigrationResult {
+  operations: MigrationOperation[];
+  getSQL?: () => string;
+  execute: () => Promise<void>;
+}
+interface Migrator {
+  /**
+   * Get current version, undefined if not initialized
+   */
+  getVersion: () => Promise<string | undefined>;
+  getNameVariants: () => Promise<NameVariantsConfig | undefined>;
+  next: () => Promise<AnySchema | undefined>;
+  previous: () => Promise<AnySchema | undefined>;
+  up: (options?: MigrateOptions) => Promise<MigrationResult>;
+  down: (options?: MigrateOptions) => Promise<MigrationResult>;
+  migrateTo: (version: string, options?: MigrateOptions) => Promise<MigrationResult>;
+  migrateToLatest: (options?: MigrateOptions) => Promise<MigrationResult>;
+}
+//#endregion
+export { AnyColumn, AnyRelation, AnySchema, AnyTable, Column, ExplicitRelation, IdColumn, Migrator, NameVariantsBuilder, Relation, Schema, Table };