@hot-updater/server 0.30.12 → 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/adapters/drizzle/index.mjs

@@ -0,0 +1,383 @@
+import { Column, IdColumn, column, idColumn, table } from "../../chunk-ZEQMAIFI.mjs";
+import { schemaToDBType } from "../../chunk-CHTIKPQU.mjs";
+import { toORM } from "../../chunk-PK2W2SQ7.mjs";
+import { importGenerator } from "../../chunk-LHHP6UVP.mjs";
+import { ident, parseVarchar } from "../../chunk-GUE4GMNC.mjs";
+import { sql } from "../../../../../../drizzle-orm@0.44.7_@cloudflare_workers-types@4.20260313.1_@electric-sql_pglite@0.2.17_@_31f44b782f9321d71f3ce9d35aa1edf7/node_modules/drizzle-orm/sql/sql.mjs";
+import { and, eq, gt, gte, inArray, isNotNull, isNull, like, lt, lte, ne, not, notInArray, notLike, or } from "../../../../../../drizzle-orm@0.44.7_@cloudflare_workers-types@4.20260313.1_@electric-sql_pglite@0.2.17_@_31f44b782f9321d71f3ce9d35aa1edf7/node_modules/drizzle-orm/sql/expressions/conditions.mjs";
+import { asc, desc } from "../../../../../../drizzle-orm@0.44.7_@cloudflare_workers-types@4.20260313.1_@electric-sql_pglite@0.2.17_@_31f44b782f9321d71f3ce9d35aa1edf7/node_modules/drizzle-orm/sql/expressions/select.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/adapters/drizzle/index.js
+function generateSchema(schema, provider) {
+	const imports = 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: 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: ${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 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) => [
+${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(`{
+${ident(options.join(",\n"))}
+}`);
+			cols.push(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 Column) right = toDrizzle(right);
+		let inverse = false;
+		switch (op) {
+			case "=": return eq(left, right);
+			case "!=": return ne(left, right);
+			case ">": return gt(left, right);
+			case ">=": return gte(left, right);
+			case "<": return lt(left, right);
+			case "<=": return lte(left, right);
+			case "in": return inArray(left, right);
+			case "not in": return notInArray(left, right);
+			case "is": return right === null ? isNull(left) : eq(left, right);
+			case "is not": return right === null ? isNotNull(left) : ne(left, right);
+			case "not contains": inverse = true;
+			case "contains":
+				right = typeof right === "string" ? `%${right}%` : sql`concat('%', ${right}, '%')`;
+				return inverse ? notLike(left, right) : like(left, right);
+			case "not ends with": inverse = true;
+			case "ends with":
+				right = typeof right === "string" ? `%${right}` : sql`concat('%', ${right})`;
+				return inverse ? notLike(left, right) : like(left, right);
+			case "not starts with": inverse = true;
+			case "starts with":
+				right = typeof right === "string" ? `${right}%` : sql`concat(${right}, '%')`;
+				return inverse ? notLike(left, right) : like(left, right);
+			default: throw new Error(`Unsupported operator: ${op}`);
+		}
+	}
+	if (condition.type === 0) return and(...condition.items.map((item) => buildWhere(toDrizzle, item)));
+	if (condition.type === 3) {
+		const result = buildWhere(toDrizzle, condition.item);
+		if (!result) return;
+		return not(result);
+	}
+	return 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" ? asc(toDrizzleColumn(item)) : 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 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(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(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 = table(settings, {
+				id: idColumn("id", "varchar(255)"),
+				version: 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
+export { drizzleAdapter };

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

@@ -0,0 +1,4 @@
+require("../../chunk-ZEQMAIFI.cjs");
+require("../../chunk-C6OTUURW.cjs");
+require("../../chunk-PK2W2SQ7.cjs");
+require("../../chunk-LVCPMTAT.cjs");

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

@@ -0,0 +1,5 @@
+import "../../chunk-ZEQMAIFI.mjs";
+import "../../chunk-C6OTUURW.mjs";
+import "../../chunk-PK2W2SQ7.mjs";
+import "../../chunk-LVCPMTAT.mjs";
+export {};