@hot-updater/server 0.33.1 → 0.34.0

package/dist/node_modules/.pnpm/fumadb@0.2.2_mongodb@6.20.0_@aws-sdk_credential-providers@3.1066.0_socks@2.8.9__prisma@_ee79457f0e32f18f0beb5c2db02e4f73/node_modules/fumadb/dist/chunk-ZOCGSAWS.mjs

@@ -1,212 +0,0 @@
-//#region ../../node_modules/.pnpm/fumadb@0.2.2_mongodb@6.20.0_@aws-sdk+credential-providers@3.1066.0_socks@2.8.9__prisma@_ee79457f0e32f18f0beb5c2db02e4f73/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_mongodb@6.20.0_@aws-sdk_credential-providers@3.1066.0_socks@2.8.9__prisma@_ee79457f0e32f18f0beb5c2db02e4f73/node_modules/fumadb/dist/create-tg0451Y_.d.cts

@@ -1,285 +0,0 @@
-//#region ../../node_modules/.pnpm/fumadb@0.2.2_mongodb@6.20.0_@aws-sdk+credential-providers@3.1066.0_socks@2.8.9__prisma@_ee79457f0e32f18f0beb5c2db02e4f73/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 };