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

@@ -1,383 +0,0 @@
-const require_chunk_ZEQMAIFI = require("../../chunk-ZEQMAIFI.cjs");
-const require_chunk_CHTIKPQU = require("../../chunk-CHTIKPQU.cjs");
-const require_chunk_PK2W2SQ7 = require("../../chunk-PK2W2SQ7.cjs");
-const require_chunk_LHHP6UVP = require("../../chunk-LHHP6UVP.cjs");
-const require_chunk_GUE4GMNC = require("../../chunk-GUE4GMNC.cjs");
-const require_sql = require("../../../../../../drizzle-orm@0.45.2_@cloudflare_workers-types@4.20260611.1_@electric-sql_pglite@0.4.1_@l_601a3995dfc55b0b7fac93cbe1e76579/node_modules/drizzle-orm/sql/sql.cjs");
-const require_conditions = require("../../../../../../drizzle-orm@0.45.2_@cloudflare_workers-types@4.20260611.1_@electric-sql_pglite@0.4.1_@l_601a3995dfc55b0b7fac93cbe1e76579/node_modules/drizzle-orm/sql/expressions/conditions.cjs");
-const require_select = require("../../../../../../drizzle-orm@0.45.2_@cloudflare_workers-types@4.20260611.1_@electric-sql_pglite@0.4.1_@l_601a3995dfc55b0b7fac93cbe1e76579/node_modules/drizzle-orm/sql/expressions/select.cjs");
-//#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/adapters/drizzle/index.js
-function generateSchema(schema, provider) {
-	const imports = require_chunk_LHHP6UVP.importGenerator();
-	const importSource = {
-		mysql: "drizzle-orm/mysql-core",
-		postgresql: "drizzle-orm/pg-core",
-		sqlite: "drizzle-orm/sqlite-core"
-	}[provider];
-	const tableFn = {
-		mysql: "mysqlTable",
-		postgresql: "pgTable",
-		sqlite: "sqliteTable"
-	}[provider];
-	const generatedCustomTypes = /* @__PURE__ */ new Set();
-	function generateCustomType(name, options) {
-		if (generatedCustomTypes.has(name)) return;
-		imports.addImport("customType", importSource);
-		generatedCustomTypes.add(name);
-		return `const ${name} = customType<
-  {
-    data: ${options.dataType};
-    driverData: ${options.driverDataType};
-  }
->({
-  dataType() {
-    return "${options.databaseDataType}";
-  },
-  fromDriver(value) {
-    ${options.fromDriverCode}
-  },
-  toDriver(value) {
-    ${options.toDriverCode}
-  }
-});`;
-	}
-	function generateBinary() {
-		const name = "customBinary";
-		const code = generateCustomType(name, {
-			dataType: "Uint8Array",
-			driverDataType: "Buffer",
-			databaseDataType: require_chunk_CHTIKPQU.schemaToDBType({ type: "binary" }, provider),
-			fromDriverCode: "return new Uint8Array(value.buffer, value.byteOffset, value.byteLength)",
-			toDriverCode: `return value instanceof Buffer? value : Buffer.from(value)`
-		});
-		if (code) lines.push(code);
-		return name;
-	}
-	function getColumnTypeFunction(column2) {
-		if (provider === "sqlite") switch (column2.type) {
-			case "uuid": return { name: "text" };
-			case "bigint": return {
-				name: "blob",
-				params: [`{ mode: "bigint" }`]
-			};
-			case "bool": return {
-				name: "integer",
-				params: [`{ mode: "boolean" }`]
-			};
-			case "json": return {
-				name: "blob",
-				params: [`{ mode: "json" }`]
-			};
-			case "timestamp":
-			case "date": return {
-				name: "integer",
-				params: [`{ mode: "timestamp" }`]
-			};
-			case "decimal": return { name: "real" };
-		}
-		switch (column2.type) {
-			case "uuid":
-				if (provider === "postgresql") return { name: "uuid" };
-				else if (provider === "mysql") return {
-					name: "char",
-					params: [`{ length: 36 }`]
-				};
-				return { name: "text" };
-			case "string": return { name: "text" };
-			case "binary": return {
-				name: generateBinary(),
-				isCustomType: true
-			};
-			case "bool": return { name: "boolean" };
-			default:
-				if (column2.type.startsWith("varchar")) return {
-					name: provider === "sqlite" ? "text" : "varchar",
-					params: [`{ length: ${require_chunk_GUE4GMNC.parseVarchar(column2.type)} }`]
-				};
-				return { name: column2.type };
-		}
-	}
-	function generateTable(table2) {
-		const cols = [];
-		for (const column2 of Object.values(table2.columns)) {
-			const col = [];
-			const typeFn = getColumnTypeFunction(column2);
-			const params = [`"${column2.names.sql}"`, ...typeFn.params ?? []];
-			if (!typeFn.isCustomType) imports.addImport(typeFn.name, importSource);
-			col.push(`${typeFn.name}(${params.join(", ")})`);
-			if (column2 instanceof require_chunk_ZEQMAIFI.IdColumn) col.push("primaryKey()");
-			if (column2.isUnique) col.push("unique()");
-			if (!column2.isNullable) col.push("notNull()");
-			if (column2.default) {
-				if ("value" in column2.default) {
-					const value = JSON.stringify(column2.default.value);
-					col.push(`default(${value})`);
-				} else if (column2.default.runtime === "auto") {
-					imports.addImport("createId", "fumadb/cuid");
-					col.push("$defaultFn(() => createId())");
-				} else if (column2.default.runtime === "now") col.push("defaultNow()");
-			}
-			cols.push(`  ${column2.names.drizzle}: ${col.join(".")}`);
-		}
-		const args = [`"${table2.names.sql}"`];
-		args.push(`{
-${cols.join(",\n")}
-}`);
-		const keys = [];
-		for (const key of table2.foreignKeys) {
-			const referencedTable = key.referencedTable;
-			const columns = key.columns.map((col) => `table.${col.names.drizzle}`);
-			const foreignColumns = key.referencedColumns.map((col) => `${referencedTable.names.drizzle}.${col.names.drizzle}`);
-			imports.addImport("foreignKey", importSource);
-			let code = `foreignKey({
-  columns: [${columns.join(", ")}],
-  foreignColumns: [${foreignColumns.join(", ")}],
-  name: "${key.name}"
-})`;
-			if (key?.onUpdate) code += `.onUpdate("${key.onUpdate.toLowerCase()}")`;
-			if (key?.onDelete) code += `.onDelete("${key.onDelete.toLowerCase()}")`;
-			keys.push(code);
-		}
-		for (const con of table2.getUniqueConstraints("table")) {
-			imports.addImport("uniqueIndex", importSource);
-			keys.push(`uniqueIndex("${con.name}").on(${con.columns.map((col) => `table.${col.names.drizzle}`).join(", ")})`);
-		}
-		if (keys.length > 0) args.push(`(table) => [
-${require_chunk_GUE4GMNC.ident(keys.join(",\n"))}
-]`);
-		return `export const ${table2.names.drizzle} = ${tableFn}(${args.join(", ")})`;
-	}
-	function generateRelation(table2) {
-		const cols = [];
-		for (const relation of Object.values(table2.relations)) {
-			const options = [`relationName: "${relation.id}"`];
-			if (!relation.implied || relation.type === "one") {
-				const fields = [];
-				const references = [];
-				for (const [left, right] of relation.on) {
-					fields.push(`${table2.names.drizzle}.${table2.columns[left].names.drizzle}`);
-					references.push(`${relation.table.names.drizzle}.${relation.table.columns[right].names.drizzle}`);
-				}
-				options.push(`fields: [${fields.join(", ")}]`, `references: [${references.join(", ")}]`);
-			}
-			const args = [];
-			args.push(relation.table.names.drizzle);
-			if (options.length > 0) args.push(`{
-${require_chunk_GUE4GMNC.ident(options.join(",\n"))}
-}`);
-			cols.push(require_chunk_GUE4GMNC.ident(`${relation.name}: ${relation.type}(${args.join(", ")})`));
-		}
-		if (cols.length === 0) return;
-		imports.addImport("relations", "drizzle-orm");
-		return `export const ${table2.names.drizzle}Relations = relations(${table2.names.drizzle}, ({ one, many }) => ({
-${cols.join(",\n")}
-}));`;
-	}
-	imports.addImport(tableFn, importSource);
-	const lines = [];
-	for (const table2 of Object.values(schema.tables)) {
-		lines.push(generateTable(table2));
-		const relation = generateRelation(table2);
-		if (relation) lines.push(relation);
-	}
-	lines.unshift(imports.format());
-	return lines.join("\n\n");
-}
-function parseDrizzle(drizzle) {
-	const db = drizzle;
-	const drizzleTables = db._.fullSchema;
-	if (!drizzleTables || Object.keys(drizzleTables).length === 0) throw new Error("[fumadb] Drizzle adapter requires query mode, make sure to configure it following their guide: https://orm.drizzle.team/docs/rqb.");
-	return [db, drizzleTables];
-}
-function buildWhere(toDrizzle, condition) {
-	if (condition.type === 2) {
-		const left = toDrizzle(condition.a);
-		const op = condition.operator;
-		let right = condition.b;
-		if (right instanceof require_chunk_ZEQMAIFI.Column) right = toDrizzle(right);
-		let inverse = false;
-		switch (op) {
-			case "=": return require_conditions.eq(left, right);
-			case "!=": return require_conditions.ne(left, right);
-			case ">": return require_conditions.gt(left, right);
-			case ">=": return require_conditions.gte(left, right);
-			case "<": return require_conditions.lt(left, right);
-			case "<=": return require_conditions.lte(left, right);
-			case "in": return require_conditions.inArray(left, right);
-			case "not in": return require_conditions.notInArray(left, right);
-			case "is": return right === null ? require_conditions.isNull(left) : require_conditions.eq(left, right);
-			case "is not": return right === null ? require_conditions.isNotNull(left) : require_conditions.ne(left, right);
-			case "not contains": inverse = true;
-			case "contains":
-				right = typeof right === "string" ? `%${right}%` : require_sql.sql`concat('%', ${right}, '%')`;
-				return inverse ? require_conditions.notLike(left, right) : require_conditions.like(left, right);
-			case "not ends with": inverse = true;
-			case "ends with":
-				right = typeof right === "string" ? `%${right}` : require_sql.sql`concat('%', ${right})`;
-				return inverse ? require_conditions.notLike(left, right) : require_conditions.like(left, right);
-			case "not starts with": inverse = true;
-			case "starts with":
-				right = typeof right === "string" ? `${right}%` : require_sql.sql`concat(${right}, '%')`;
-				return inverse ? require_conditions.notLike(left, right) : require_conditions.like(left, right);
-			default: throw new Error(`Unsupported operator: ${op}`);
-		}
-	}
-	if (condition.type === 0) return require_conditions.and(...condition.items.map((item) => buildWhere(toDrizzle, item)));
-	if (condition.type === 3) {
-		const result = buildWhere(toDrizzle, condition.item);
-		if (!result) return;
-		return require_conditions.not(result);
-	}
-	return require_conditions.or(...condition.items.map((item) => buildWhere(toDrizzle, item)));
-}
-function mapValues(values, table2) {
-	const out = {};
-	for (const column2 of Object.values(table2.columns)) out[column2.names.drizzle] = values[column2.ormName];
-	return out;
-}
-function mapQueryResult(table2, result) {
-	const out = {};
-	for (const k in result) {
-		const value = result[k];
-		if (k in table2.relations) {
-			const relation = table2.relations[k];
-			if (relation.type === "many") {
-				out[k] = value.map((v) => mapQueryResult(relation.table, v));
-				continue;
-			}
-			out[k] = value ? mapQueryResult(relation.table, value) : null;
-			continue;
-		}
-		const col = table2.getColumnByName(k, "drizzle");
-		if (!col) continue;
-		out[col.ormName] = value;
-	}
-	return out;
-}
-function fromDrizzle(schema, _db, provider) {
-	const [db, drizzleTables] = parseDrizzle(_db);
-	function toDrizzle(v) {
-		const out = drizzleTables[v.names.drizzle];
-		if (out) return out;
-		throw new Error(`[FumaDB Drizzle] Unknown table name ${v.names.drizzle}, is it included in your Drizzle schema?`);
-	}
-	function toDrizzleColumn(v) {
-		const out = toDrizzle(v.table)[v.names.drizzle];
-		if (out) return out;
-		throw new Error(`[FumaDB Drizzle] Unknown column name ${v.names.drizzle} in ${v.table.names.drizzle}.`);
-	}
-	function buildQueryConfig(table2, options) {
-		const columns = {};
-		const select = options.select;
-		if (select === true) for (const col of Object.values(table2.columns)) columns[col.names.drizzle] = true;
-		else for (const k of select) columns[table2.columns[k].names.drizzle] = true;
-		const out = {
-			columns,
-			limit: options.limit,
-			offset: options.offset,
-			where: options.where ? buildWhere(toDrizzleColumn, options.where) : void 0,
-			orderBy: options.orderBy?.map(([item, mode]) => mode === "asc" ? require_select.asc(toDrizzleColumn(item)) : require_select.desc(toDrizzleColumn(item)))
-		};
-		if (options.join) {
-			out.with = {};
-			for (const join of options.join) {
-				if (join.options === false) continue;
-				out.with[join.relation.name] = buildQueryConfig(join.relation.table, join.options);
-			}
-		}
-		return out;
-	}
-	return require_chunk_PK2W2SQ7.toORM({
-		tables: schema.tables,
-		async count(table2, v) {
-			return await db.$count(toDrizzle(table2), v.where ? buildWhere(toDrizzleColumn, v.where) : void 0);
-		},
-		async findFirst(table2, v) {
-			return (await this.findMany(table2, {
-				...v,
-				limit: 1
-			}))[0] ?? null;
-		},
-		async upsert(table2, v) {
-			const idField = table2.getIdColumn().names.drizzle;
-			const drizzleTable = toDrizzle(table2);
-			let query = db.select({ id: drizzleTable[idField] }).from(drizzleTable).limit(1);
-			if (v.where) query = query.where(buildWhere(toDrizzleColumn, v.where));
-			const targetIds = await query.execute();
-			if (targetIds.length > 0) await db.update(drizzleTable).set(mapValues(v.update, table2)).where(require_conditions.eq(drizzleTable[idField], targetIds[0].id));
-			else await this.createMany(table2, [v.create]);
-		},
-		async findMany(table2, v) {
-			return (await db.query[table2.names.drizzle].findMany(buildQueryConfig(table2, v))).map((v2) => mapQueryResult(table2, v2));
-		},
-		async updateMany(table2, v) {
-			const drizzleTable = toDrizzle(table2);
-			let query = db.update(drizzleTable).set(mapValues(v.set, table2));
-			if (v.where) query = query.where(buildWhere(toDrizzleColumn, v.where));
-			await query;
-		},
-		async create(table2, values) {
-			const idField = table2.getIdColumn().names.drizzle;
-			const drizzleTable = toDrizzle(table2);
-			values = mapValues(values, table2);
-			const returning = {};
-			for (const column2 of Object.values(table2.columns)) returning[column2.ormName] = drizzleTable[column2.names.drizzle];
-			if (provider === "sqlite" || provider === "postgresql") return (await db.insert(drizzleTable).values(values).returning(returning))[0];
-			const obj = (await db.insert(drizzleTable).values(values).$returningId())[0];
-			return (await db.select(returning).from(drizzleTable).where(require_conditions.eq(drizzleTable[idField], obj[idField])).limit(1))[0];
-		},
-		async createMany(table2, values) {
-			const idField = table2.getIdColumn().names.drizzle;
-			const drizzleTable = toDrizzle(table2);
-			values = values.map((v) => mapValues(v, table2));
-			if (provider === "sqlite" || provider === "postgresql") return await db.insert(drizzleTable).values(values).returning({ _id: drizzleTable[idField] });
-			return (await db.insert(drizzleTable).values(values).$returningId()).map((result) => ({ _id: result[idField] }));
-		},
-		async deleteMany(table2, v) {
-			const drizzleTable = toDrizzle(table2);
-			let query = db.delete(drizzleTable);
-			if (v.where) query = query.where(buildWhere(toDrizzleColumn, v.where));
-			await query;
-		},
-		transaction(run) {
-			return db.transaction((tx) => run(fromDrizzle(schema, tx, provider)));
-		}
-	});
-}
-function drizzleAdapter(options) {
-	const settingsTableName = (namespace) => `private_${namespace}_settings`;
-	return {
-		name: "drizzle",
-		createORM(schema) {
-			return fromDrizzle(schema, options.db, options.provider);
-		},
-		async getSchemaVersion() {
-			const [_db, tables] = parseDrizzle(options.db);
-			const table2 = tables[settingsTableName(this.namespace)];
-			if (!table2) return;
-			const col = table2["version"];
-			if (!col) return;
-			return col.default;
-		},
-		generateSchema(schema, schemaName) {
-			const settings = settingsTableName(this.namespace);
-			const internalTable = require_chunk_ZEQMAIFI.table(settings, {
-				id: require_chunk_ZEQMAIFI.idColumn("id", "varchar(255)"),
-				version: require_chunk_ZEQMAIFI.column("version", "varchar(255)").defaultTo(schema.version)
-			});
-			internalTable.ormName = settings;
-			return {
-				code: generateSchema({
-					...schema,
-					tables: {
-						...schema.tables,
-						[settings]: internalTable
-					}
-				}, options.provider),
-				path: `./db/${schemaName}.ts`
-			};
-		}
-	};
-}
-//#endregion
-exports.drizzleAdapter = drizzleAdapter;

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

@@ -1,12 +0,0 @@
-import { FumaDBAdapter, Provider } from "../../index-CMqePMTF.cjs";
-//#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/adapters/drizzle/index.d.ts
-interface DrizzleConfig {
-  /**
-   * Drizzle instance, must have query mode configured: https://orm.drizzle.team/docs/rqb.
-   */
-  db: unknown;
-  provider: Exclude<Provider, "cockroachdb" | "mongodb" | "mssql" | "convex">;
-}
-declare function drizzleAdapter(options: DrizzleConfig): FumaDBAdapter;
-//#endregion
-export { drizzleAdapter };

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

@@ -1,12 +0,0 @@
-import { FumaDBAdapter, Provider } from "../../index-CMqePMTF.mjs";
-//#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/adapters/drizzle/index.d.ts
-interface DrizzleConfig {
-  /**
-   * Drizzle instance, must have query mode configured: https://orm.drizzle.team/docs/rqb.
-   */
-  db: unknown;
-  provider: Exclude<Provider, "cockroachdb" | "mongodb" | "mssql" | "convex">;
-}
-declare function drizzleAdapter(options: DrizzleConfig): FumaDBAdapter;
-//#endregion
-export { drizzleAdapter };