@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/create-tg0451Y_.d.mts

@@ -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 };

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/index-CMqePMTF.d.cts

@@ -0,0 +1,45 @@
+import { AnySchema, Migrator } from "./create-tg0451Y_.cjs";
+import { AbstractQuery } from "./query/index.cjs";
+//#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/index-CMqePMTF.d.ts
+declare const sqlProviders: readonly ["sqlite", "cockroachdb", "mysql", "postgresql", "mssql"];
+declare const providers: readonly ["sqlite", "cockroachdb", "mysql", "postgresql", "mssql", "mongodb"];
+type Provider = (typeof providers)[number];
+type SQLProvider = (typeof sqlProviders)[number];
+interface LibraryConfig<Schemas extends AnySchema[] = AnySchema[]> {
+  namespace: string;
+  /**
+   * different versions of schemas (sorted in ascending order)
+   */
+  schemas: Schemas;
+  /**
+   * The initial version, it refers to the version of database **before** being initialized.
+   *
+   * You should not use this version number in your schemas.
+   *
+   * @defaultValue '0.0.0'
+   */
+  initialVersion?: string;
+}
+type RelationMode = "foreign-keys" | "fumadb";
+interface FumaDBAdapterContext extends LibraryConfig {}
+interface FumaDBAdapter {
+  /**
+   * Name of the adapter
+   */
+  name: string;
+  /**
+   * Generate ORM schema based on FumaDB Schema
+   */
+  generateSchema?: (this: FumaDBAdapterContext, schema: AnySchema, schemaName: string) => {
+    code: string;
+    path: string;
+  };
+  createORM(this: FumaDBAdapterContext, schema: AnySchema): AbstractQuery<AnySchema>;
+  /**
+   * Get current schema version, undefined if not initialized.
+   */
+  getSchemaVersion(this: FumaDBAdapterContext): Promise<string | undefined>;
+  createMigrationEngine?: (this: FumaDBAdapterContext) => Migrator;
+}
+//#endregion
+export { FumaDBAdapter, LibraryConfig, Provider, RelationMode, SQLProvider, providers, sqlProviders };

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/index-CMqePMTF.d.mts

@@ -0,0 +1,45 @@
+import { AnySchema, Migrator } from "./create-tg0451Y_.mjs";
+import { AbstractQuery } from "./query/index.mjs";
+//#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/index-CMqePMTF.d.ts
+declare const sqlProviders: readonly ["sqlite", "cockroachdb", "mysql", "postgresql", "mssql"];
+declare const providers: readonly ["sqlite", "cockroachdb", "mysql", "postgresql", "mssql", "mongodb"];
+type Provider = (typeof providers)[number];
+type SQLProvider = (typeof sqlProviders)[number];
+interface LibraryConfig<Schemas extends AnySchema[] = AnySchema[]> {
+  namespace: string;
+  /**
+   * different versions of schemas (sorted in ascending order)
+   */
+  schemas: Schemas;
+  /**
+   * The initial version, it refers to the version of database **before** being initialized.
+   *
+   * You should not use this version number in your schemas.
+   *
+   * @defaultValue '0.0.0'
+   */
+  initialVersion?: string;
+}
+type RelationMode = "foreign-keys" | "fumadb";
+interface FumaDBAdapterContext extends LibraryConfig {}
+interface FumaDBAdapter {
+  /**
+   * Name of the adapter
+   */
+  name: string;
+  /**
+   * Generate ORM schema based on FumaDB Schema
+   */
+  generateSchema?: (this: FumaDBAdapterContext, schema: AnySchema, schemaName: string) => {
+    code: string;
+    path: string;
+  };
+  createORM(this: FumaDBAdapterContext, schema: AnySchema): AbstractQuery<AnySchema>;
+  /**
+   * Get current schema version, undefined if not initialized.
+   */
+  getSchemaVersion(this: FumaDBAdapterContext): Promise<string | undefined>;
+  createMigrationEngine?: (this: FumaDBAdapterContext) => Migrator;
+}
+//#endregion
+export { FumaDBAdapter, LibraryConfig, Provider, RelationMode, SQLProvider, providers, sqlProviders };

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/index.cjs

@@ -0,0 +1,69 @@
+require("../../../../../../_virtual/_rolldown/runtime.cjs");
+const require_chunk_7PZK4ONR = require("./chunk-7PZK4ONR.cjs");
+let semver = require("semver");
+//#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/index.js
+var sqlProviders = [
+	"sqlite",
+	"cockroachdb",
+	"mysql",
+	"postgresql",
+	"mssql"
+];
+var noSqlProviders = ["mongodb"];
+[...sqlProviders, ...noSqlProviders];
+function fumadb(config) {
+	const schemas = config.schemas.sort((a, b) => (0, semver.compare)(a.version, b.version));
+	return {
+		names: require_chunk_7PZK4ONR.createNameVariantsBuilder(config.namespace, schemas, (schemas2) => {
+			return fumadb({
+				...config,
+				schemas: schemas2
+			});
+		}),
+		version(targetVersion) {
+			return targetVersion;
+		},
+		client(adapter) {
+			const orms = /* @__PURE__ */ new Map();
+			const adapterContext = { ...config };
+			return {
+				adapter,
+				schemas,
+				orm(version) {
+					let orm = orms.get(version);
+					if (orm) return orm;
+					const schema = schemas.find((schema2) => schema2.version === version);
+					if (!schema) throw new Error(`unknown schema version ${version}`);
+					orm = adapter.createORM.call(adapterContext, schema);
+					orms.set(version, orm);
+					return orm;
+				},
+				async version() {
+					const version = await adapter.getSchemaVersion.call(adapterContext);
+					if (!version) throw new Error(`FumaDB ${config.namespace} is not initialized.`);
+					return version;
+				},
+				generateSchema(version, name = config.namespace) {
+					if (!adapter.generateSchema) throw new Error("The adapter doesn't support schema API.");
+					let schema;
+					if (version === "latest") schema = schemas.at(-1);
+					else {
+						schema = schemas.find((schema2) => schema2.version === version);
+						if (!schema) throw new Error(`Invalid version: ${version}`);
+					}
+					return adapter.generateSchema.call(adapterContext, schema, name);
+				},
+				createMigrator() {
+					if (!adapter.createMigrationEngine) throw new Error("The adapter doesn't support migration engine.");
+					return adapter.createMigrationEngine.call(adapterContext);
+				},
+				get abstract() {
+					return this.orm(schemas.at(-1).version);
+				}
+			};
+		}
+	};
+}
+//#endregion
+exports.fumadb = fumadb;
+exports.sqlProviders = sqlProviders;

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/index.d.cts

@@ -0,0 +1,49 @@
+import { AnySchema, Migrator, NameVariantsBuilder } from "./create-tg0451Y_.cjs";
+import { AbstractQuery } from "./query/index.cjs";
+import { FumaDBAdapter, LibraryConfig, Provider, RelationMode, SQLProvider, providers, sqlProviders } from "./index-CMqePMTF.cjs";
+//#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/index.d.ts
+type Last<T extends unknown[]> = T extends [...infer _, infer L] ? L : T[number];
+interface FumaDB<Schemas extends AnySchema[] = AnySchema[]> {
+  schemas: Schemas;
+  adapter: FumaDBAdapter;
+  /**
+   * Shorthand for `orm()` latest schema version
+   * @deprecated use `orm()` directly
+   */
+  readonly abstract: AbstractQuery<Last<Schemas>>;
+  /**
+   * Get current schema version
+   */
+  version: () => Promise<Schemas[number]["version"]>;
+  orm: <V extends Schemas[number]["version"]>(version: V) => AbstractQuery<Extract<Schemas[number], {
+    version: V;
+  }>>;
+  /**
+   * Kysely & MongoDB only
+   */
+  createMigrator: () => Migrator;
+  /**
+   * ORM only
+   */
+  generateSchema: (version: Schemas[number]["version"] | "latest", name?: string) => {
+    code: string;
+    path: string;
+  };
+}
+interface FumaDBFactory<Schemas extends AnySchema[]> {
+  /**
+   * A static type-checker
+   */
+  version: <T extends Schemas[number]["version"]>(target: T) => T;
+  /**
+   * Configure consumer-side integration
+   */
+  client: (adapter: FumaDBAdapter) => FumaDB<Schemas>;
+  /**
+   * Set name variants
+   */
+  names: NameVariantsBuilder<Schemas, FumaDBFactory<Schemas>>;
+}
+type InferFumaDB<Factory extends FumaDBFactory<any>> = Factory extends FumaDBFactory<infer Schemas> ? FumaDB<Schemas> : never;
+//#endregion
+export { type FumaDBFactory, type InferFumaDB };

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/index.d.mts

@@ -0,0 +1,49 @@
+import { AnySchema, Migrator, NameVariantsBuilder } from "./create-tg0451Y_.mjs";
+import { AbstractQuery } from "./query/index.mjs";
+import { FumaDBAdapter, LibraryConfig, Provider, RelationMode, SQLProvider, providers, sqlProviders } from "./index-CMqePMTF.mjs";
+//#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/index.d.ts
+type Last<T extends unknown[]> = T extends [...infer _, infer L] ? L : T[number];
+interface FumaDB<Schemas extends AnySchema[] = AnySchema[]> {
+  schemas: Schemas;
+  adapter: FumaDBAdapter;
+  /**
+   * Shorthand for `orm()` latest schema version
+   * @deprecated use `orm()` directly
+   */
+  readonly abstract: AbstractQuery<Last<Schemas>>;
+  /**
+   * Get current schema version
+   */
+  version: () => Promise<Schemas[number]["version"]>;
+  orm: <V extends Schemas[number]["version"]>(version: V) => AbstractQuery<Extract<Schemas[number], {
+    version: V;
+  }>>;
+  /**
+   * Kysely & MongoDB only
+   */
+  createMigrator: () => Migrator;
+  /**
+   * ORM only
+   */
+  generateSchema: (version: Schemas[number]["version"] | "latest", name?: string) => {
+    code: string;
+    path: string;
+  };
+}
+interface FumaDBFactory<Schemas extends AnySchema[]> {
+  /**
+   * A static type-checker
+   */
+  version: <T extends Schemas[number]["version"]>(target: T) => T;
+  /**
+   * Configure consumer-side integration
+   */
+  client: (adapter: FumaDBAdapter) => FumaDB<Schemas>;
+  /**
+   * Set name variants
+   */
+  names: NameVariantsBuilder<Schemas, FumaDBFactory<Schemas>>;
+}
+type InferFumaDB<Factory extends FumaDBFactory<any>> = Factory extends FumaDBFactory<infer Schemas> ? FumaDB<Schemas> : never;
+//#endregion
+export { type FumaDBFactory, type InferFumaDB };

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/index.mjs

@@ -0,0 +1,67 @@
+import { createNameVariantsBuilder } from "./chunk-7PZK4ONR.mjs";
+import { compare } from "semver";
+//#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/index.js
+var sqlProviders = [
+	"sqlite",
+	"cockroachdb",
+	"mysql",
+	"postgresql",
+	"mssql"
+];
+var noSqlProviders = ["mongodb"];
+[...sqlProviders, ...noSqlProviders];
+function fumadb(config) {
+	const schemas = config.schemas.sort((a, b) => compare(a.version, b.version));
+	return {
+		names: createNameVariantsBuilder(config.namespace, schemas, (schemas2) => {
+			return fumadb({
+				...config,
+				schemas: schemas2
+			});
+		}),
+		version(targetVersion) {
+			return targetVersion;
+		},
+		client(adapter) {
+			const orms = /* @__PURE__ */ new Map();
+			const adapterContext = { ...config };
+			return {
+				adapter,
+				schemas,
+				orm(version) {
+					let orm = orms.get(version);
+					if (orm) return orm;
+					const schema = schemas.find((schema2) => schema2.version === version);
+					if (!schema) throw new Error(`unknown schema version ${version}`);
+					orm = adapter.createORM.call(adapterContext, schema);
+					orms.set(version, orm);
+					return orm;
+				},
+				async version() {
+					const version = await adapter.getSchemaVersion.call(adapterContext);
+					if (!version) throw new Error(`FumaDB ${config.namespace} is not initialized.`);
+					return version;
+				},
+				generateSchema(version, name = config.namespace) {
+					if (!adapter.generateSchema) throw new Error("The adapter doesn't support schema API.");
+					let schema;
+					if (version === "latest") schema = schemas.at(-1);
+					else {
+						schema = schemas.find((schema2) => schema2.version === version);
+						if (!schema) throw new Error(`Invalid version: ${version}`);
+					}
+					return adapter.generateSchema.call(adapterContext, schema, name);
+				},
+				createMigrator() {
+					if (!adapter.createMigrationEngine) throw new Error("The adapter doesn't support migration engine.");
+					return adapter.createMigrationEngine.call(adapterContext);
+				},
+				get abstract() {
+					return this.orm(schemas.at(-1).version);
+				}
+			};
+		}
+	};
+}
+//#endregion
+export { fumadb, sqlProviders };