@apisr/drizzle-model 0.0.1 → 0.0.2

package/dist/index.d.mts

@@ -0,0 +1,3 @@
+import { modelBuilder } from "./model/builder.mjs";
+import "./model/index.mjs";
+export { modelBuilder };

package/dist/index.mjs

@@ -0,0 +1,4 @@
+import { modelBuilder } from "./model/builder.mjs";
+import "./model/index.mjs";
+
+export { modelBuilder };

package/dist/model/builder.d.mts

@@ -0,0 +1,20 @@
+import { ModelDialect } from "./dialect.mjs";
+import { ModelOptions } from "./options.mjs";
+import { ModelConfig } from "./config.mjs";
+import { Model } from "./model.mjs";
+import { AnyRelations, EmptyRelations } from "drizzle-orm";
+
+//#region src/model/builder.d.ts
+declare function modelBuilder<TFullSchema extends Record<string, unknown> = Record<string, never>, TRelations extends AnyRelations = EmptyRelations, TDialect extends ModelDialect = ModelDialect>({
+  db,
+  relations,
+  schema,
+  dialect
+}: {
+  relations: TRelations;
+  db: any;
+  schema: TFullSchema;
+  dialect: TDialect;
+}): <TTableName extends keyof TRelations, TOptions extends ModelOptions<TRelations, TRelations[TTableName], TDialect, TOptions>>(table: TTableName, options: TOptions) => Model<ModelConfig<TRelations, TRelations[TTableName], TDialect, TOptions>>;
+//#endregion
+export { modelBuilder };

package/dist/model/builder.mjs

@@ -0,0 +1,18 @@
+import { makeModelRuntime } from "./core/runtime.mjs";
+
+//#region src/model/builder.ts
+function modelBuilder({ db, relations, schema, dialect }) {
+	return (table, options) => {
+		return makeModelRuntime({
+			db,
+			relations,
+			schema,
+			tableName: table,
+			dialect,
+			options: options ?? {}
+		});
+	};
+}
+
+//#endregion
+export { modelBuilder };

package/dist/model/config.d.mts

@@ -0,0 +1,23 @@
+import { IsTable, TableOutput } from "./table.mjs";
+import { ModelDialect } from "./dialect.mjs";
+import { DrizzleColumnDataType } from "./query/operations.mjs";
+import { MethodWhereValue } from "./methods/query/where.mjs";
+import { ModelOptions, ResolveOptionsFormat } from "./options.mjs";
+import { GetPrimarySerialOrDefaultKeys } from "./methods/return.mjs";
+import { TableRelationalConfig, TablesRelationalConfig } from "drizzle-orm/relations";
+
+//#region src/model/config.d.ts
+type ModelConfig<TSchema extends TablesRelationalConfig = TablesRelationalConfig, TTable extends TableRelationalConfig = TableRelationalConfig, TDialect extends ModelDialect = ModelDialect, TOptions extends ModelOptions<any> = ModelOptions<any>> = {
+  schema: TSchema;
+  table: TTable;
+  dialect: TDialect;
+  options: TOptions;
+  tableOutput: TableOutput<TTable>;
+  tableColumns: IsTable<TTable["table"]>["_"]["columns"];
+  optionsFormat: ResolveOptionsFormat<TOptions["format"]>;
+  primaryKeys: keyof GetPrimarySerialOrDefaultKeys<IsTable<TTable["table"]>["_"]["columns"]>;
+  primaryKeysWithDataType: { [TKey in keyof GetPrimarySerialOrDefaultKeys<IsTable<TTable["table"]>["_"]["columns"]>]: DrizzleColumnDataType<IsTable<TTable["table"]>["_"]["columns"][TKey]> };
+  whereValue: MethodWhereValue<TSchema, TTable>;
+};
+//#endregion
+export { ModelConfig };

package/dist/model/core/joins.mjs

@@ -0,0 +1,184 @@
+import { and, eq } from "drizzle-orm";
+
+//#region src/model/core/joins.ts
+function isDrizzleColumn(value) {
+	return !!value && typeof value === "object" && typeof value.getSQL === "function";
+}
+function getPrimaryKeyField(table) {
+	for (const [k, v] of Object.entries(table)) {
+		if (!isDrizzleColumn(v)) continue;
+		if (v.primary === true) return k;
+		if (v.config?.primaryKey === true) return k;
+	}
+	if ("id" in table) return "id";
+	return Object.keys(table).find((k) => isDrizzleColumn(table[k])) ?? "id";
+}
+function isAllNullRow(obj) {
+	if (!obj || typeof obj !== "object") return true;
+	for (const v of Object.values(obj)) if (v !== null && v !== void 0) return false;
+	return true;
+}
+async function aliasTable(table, aliasName, dialect) {
+	if (dialect === "PostgreSQL") {
+		const mod = await import("drizzle-orm/pg-core");
+		if (typeof mod.alias === "function") return mod.alias(table, aliasName);
+	}
+	if (dialect === "MySQL") {
+		const mod = await import("drizzle-orm/mysql-core");
+		if (typeof mod.alias === "function") return mod.alias(table, aliasName);
+	}
+	if (dialect === "SQLite") {
+		const mod = await import("drizzle-orm/sqlite-core");
+		if (typeof mod.alias === "function") return mod.alias(table, aliasName);
+	}
+	return table;
+}
+function buildJoinOn(node) {
+	const parts = node.sourceColumns.map((src, i) => {
+		const tgt = node.targetColumns[i];
+		const tgtKey = Object.entries(node.targetTable).find(([, v]) => v === tgt)?.[0];
+		return eq(tgtKey ? node.targetAliasTable[tgtKey] : tgt, src);
+	});
+	return parts.length === 1 ? parts[0] : and(...parts);
+}
+function buildSelectMapForTable(table) {
+	const out = {};
+	for (const [k, v] of Object.entries(table)) if (isDrizzleColumn(v)) out[k] = v;
+	return out;
+}
+async function executeWithJoins(args) {
+	const { db, schema, relations, baseTableName, baseTable, dialect, whereSql, withValue, limitOne } = args;
+	const usedAliasKeys = /* @__PURE__ */ new Set();
+	const buildNode = async (parent, currentTableName, currentTable, key, value, path) => {
+		const relMeta = relations[currentTableName]?.relations?.[key];
+		if (!relMeta) throw new Error(`Unknown relation '${key}' on table '${currentTableName}'.`);
+		const targetTableName = relMeta.targetTableName;
+		const targetTable = schema[targetTableName];
+		const aliasKeyBase = [...path, key].join("__");
+		let aliasKey = aliasKeyBase;
+		let idx = 1;
+		while (usedAliasKeys.has(aliasKey)) aliasKey = `${aliasKeyBase}_${idx++}`;
+		usedAliasKeys.add(aliasKey);
+		const needsAlias = targetTableName === currentTableName || usedAliasKeys.has(`table:${targetTableName}`);
+		usedAliasKeys.add(`table:${targetTableName}`);
+		const targetAliasTable = needsAlias ? await aliasTable(targetTable, aliasKey, dialect) : targetTable;
+		const node = {
+			path: [...path, key],
+			key,
+			relationType: relMeta.relationType,
+			sourceTableName: currentTableName,
+			targetTableName,
+			sourceTable: currentTable,
+			targetTable,
+			targetAliasTable,
+			aliasKey,
+			sourceColumns: relMeta.sourceColumns ?? [],
+			targetColumns: relMeta.targetColumns ?? [],
+			pkField: getPrimaryKeyField(targetAliasTable),
+			parent,
+			children: []
+		};
+		if (value && typeof value === "object" && value !== true) for (const [childKey, childVal] of Object.entries(value)) {
+			if (childVal !== true && (typeof childVal !== "object" || childVal == null)) continue;
+			const child = await buildNode(node, targetTableName, targetAliasTable, childKey, childVal, [...path, key]);
+			node.children.push(child);
+		}
+		return node;
+	};
+	const root = {
+		path: [],
+		key: "$root",
+		relationType: "one",
+		sourceTableName: baseTableName,
+		targetTableName: baseTableName,
+		sourceTable: baseTable,
+		targetTable: baseTable,
+		targetAliasTable: baseTable,
+		aliasKey: "$base",
+		sourceColumns: [],
+		targetColumns: [],
+		pkField: getPrimaryKeyField(baseTable),
+		children: []
+	};
+	for (const [key, value] of Object.entries(withValue)) {
+		if (value !== true && (typeof value !== "object" || value == null)) continue;
+		const child = await buildNode(void 0, baseTableName, baseTable, key, value, []);
+		root.children.push(child);
+	}
+	const nodes = [];
+	const walk = (n) => {
+		for (const c of n.children) {
+			nodes.push(c);
+			walk(c);
+		}
+	};
+	walk(root);
+	const selectMap = { base: buildSelectMapForTable(baseTable) };
+	for (const n of nodes) selectMap[n.aliasKey] = buildSelectMapForTable(n.targetAliasTable);
+	let q = db.select(selectMap).from(baseTable);
+	if (whereSql) q = q.where(whereSql);
+	for (const n of nodes) {
+		const on = buildJoinOn(n);
+		q = q.leftJoin(n.targetAliasTable, on);
+	}
+	if (limitOne) q = q.limit(1);
+	const rows = await q;
+	const basePk = root.pkField;
+	const baseMap = /* @__PURE__ */ new Map();
+	const ensureManyContainer = (obj, key) => {
+		if (!Array.isArray(obj[key])) obj[key] = [];
+	};
+	const ensureOneContainer = (obj, key) => {
+		if (!(key in obj)) obj[key] = null;
+	};
+	const manyIndexByPath = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const baseRow = row.base;
+		const baseId = baseRow[basePk];
+		if (baseId === void 0) continue;
+		const baseObj = (() => {
+			const existing = baseMap.get(baseId);
+			if (existing) return existing;
+			const created = { ...baseRow };
+			baseMap.set(baseId, created);
+			return created;
+		})();
+		for (const n of nodes) {
+			const data = row[n.aliasKey];
+			const relPath = n.path.join(".");
+			const parentPath = n.parent ? n.parent.path.join(".") : "";
+			let parentObj = baseObj;
+			if (parentPath) {
+				const parentIndex = manyIndexByPath.get(parentPath);
+				if (parentIndex && parentIndex.size) parentObj = Array.from(parentIndex.values()).at(-1);
+				else {
+					const parentKey = n.parent?.key;
+					parentObj = parentKey ? baseObj[parentKey] ?? baseObj : baseObj;
+				}
+			}
+			if (isAllNullRow(data)) {
+				if (n.relationType === "one") ensureOneContainer(parentObj, n.key);
+				else ensureManyContainer(parentObj, n.key);
+				continue;
+			}
+			const pk = data[n.pkField];
+			if (n.relationType === "one") parentObj[n.key] = { ...data };
+			else {
+				ensureManyContainer(parentObj, n.key);
+				const indexKey = relPath;
+				if (!manyIndexByPath.has(indexKey)) manyIndexByPath.set(indexKey, /* @__PURE__ */ new Map());
+				const idxMap = manyIndexByPath.get(indexKey);
+				if (!idxMap.has(pk)) {
+					const obj = { ...data };
+					idxMap.set(pk, obj);
+					parentObj[n.key].push(obj);
+				}
+			}
+		}
+	}
+	const out = Array.from(baseMap.values());
+	return limitOne ? out[0] : out;
+}
+
+//#endregion
+export { executeWithJoins };

package/dist/model/core/projection.mjs

@@ -0,0 +1,28 @@
+//#region src/model/core/projection.ts
+function isDrizzleColumn(value) {
+	return !!value && typeof value === "object" && typeof value.getSQL === "function";
+}
+function getTableColumnsMap(table) {
+	const out = {};
+	for (const [key, value] of Object.entries(table)) if (isDrizzleColumn(value)) out[key] = value;
+	return out;
+}
+function buildSelectProjection(table, select, exclude) {
+	const all = getTableColumnsMap(table);
+	if (select && typeof select === "object") {
+		const picked = {};
+		for (const [key, value] of Object.entries(select)) if (value === true && key in all) picked[key] = all[key];
+		if (Object.keys(picked).length) return { selectMap: picked };
+		return { selectMap: all };
+	}
+	if (exclude && typeof exclude === "object") {
+		const omitted = { ...all };
+		for (const [key, value] of Object.entries(exclude)) if (value === true) delete omitted[key];
+		if (Object.keys(omitted).length) return { selectMap: omitted };
+		return { selectMap: all };
+	}
+	return { selectMap: all };
+}
+
+//#endregion
+export { buildSelectProjection };

package/dist/model/core/runtime.mjs

@@ -0,0 +1,198 @@
+import { MutateResult, QueryResult } from "./thenable.mjs";
+import { applyExclude, applyFormat, applySelect } from "./transform.mjs";
+import { buildSelectProjection } from "./projection.mjs";
+import { compileWhere } from "./where.mjs";
+import { runWithJoins } from "./with.mjs";
+import { and } from "drizzle-orm";
+
+//#region src/model/core/runtime.ts
+function compileEffectiveWhere(table, optionsWhere, stateWhere) {
+	const base = compileWhere(table, optionsWhere);
+	const extra = compileWhere(table, stateWhere);
+	if (base && extra) return and(base, extra);
+	return base ?? extra;
+}
+function isReturningIdDialect(dialect) {
+	return dialect === "MySQL" || dialect === "SingleStore" || dialect === "CockroachDB";
+}
+async function execReturn(q, mState, dialect) {
+	if (typeof q?.returning === "function") return await (mState.returnSelect ? q.returning(mState.returnSelect) : q.returning());
+	if (isReturningIdDialect(dialect) && typeof q?.$returningId === "function") return await q.$returningId();
+	return await q;
+}
+function normalizeUpsertTarget(table, target) {
+	if (!target) return target;
+	if (typeof target === "string") return table[target] ?? target;
+	if (Array.isArray(target)) return target.map((t) => typeof t === "string" ? table[t] ?? t : t);
+	return target;
+}
+function makeModelRuntime(config) {
+	const baseState = {
+		db: config.db,
+		where: void 0
+	};
+	const build = (state) => {
+		const modelObj = {
+			$model: "model",
+			$modelName: config.tableName,
+			$format: config.options.format,
+			$formatValue: void 0,
+			where(value) {
+				return build({
+					...state,
+					where: value
+				});
+			},
+			include(value) {
+				return value;
+			},
+			extend(nextOptions) {
+				return makeModelRuntime({
+					...config,
+					options: {
+						...config.options,
+						...nextOptions,
+						methods: {
+							...nextOptions?.methods ?? {},
+							...config.options?.methods ?? {}
+						},
+						format: nextOptions?.format ?? config.options?.format
+					}
+				});
+			},
+			db(db) {
+				return makeModelRuntime({
+					...config,
+					db
+				});
+			}
+		};
+		const attachMethods = (methods) => {
+			if (!methods) return;
+			for (const [key, fn] of Object.entries(methods)) if (typeof fn === "function") modelObj[key] = fn.bind(modelObj);
+		};
+		attachMethods(config.options.methods);
+		modelObj.findMany = () => {
+			const runner = async (qState) => {
+				const table = config.schema[config.tableName];
+				const whereSql = compileEffectiveWhere(table, config.options.where, state.where);
+				let result;
+				if (qState.with) result = await runWithJoins({
+					db: config.db,
+					schema: config.schema,
+					relations: config.relations,
+					tableName: config.tableName,
+					table,
+					dialect: config.dialect,
+					whereSql,
+					qState,
+					kind: "many"
+				});
+				else {
+					const { selectMap } = buildSelectProjection(table, qState.select, qState.exclude);
+					let q = config.db.select(selectMap).from(table);
+					if (whereSql) q = q.where(whereSql);
+					result = await q;
+				}
+				let out = result;
+				if (qState.select) out = applySelect(out, qState.select);
+				if (qState.exclude) out = applyExclude(out, qState.exclude);
+				if (!qState.raw) out = applyFormat(out, config.options.format);
+				return out;
+			};
+			return new QueryResult({}, runner);
+		};
+		modelObj.findFirst = () => {
+			const runner = async (qState) => {
+				const table = config.schema[config.tableName];
+				const whereSql = compileEffectiveWhere(table, config.options.where, state.where);
+				let result;
+				if (qState.with) result = await runWithJoins({
+					db: config.db,
+					schema: config.schema,
+					relations: config.relations,
+					tableName: config.tableName,
+					table,
+					dialect: config.dialect,
+					whereSql,
+					qState,
+					kind: "one"
+				});
+				else {
+					const { selectMap } = buildSelectProjection(table, qState.select, qState.exclude);
+					let q = config.db.select(selectMap).from(table);
+					if (whereSql) q = q.where(whereSql);
+					q = q.limit(1);
+					result = (await q)[0];
+				}
+				let out = result;
+				if (qState.select) out = applySelect(out, qState.select);
+				if (qState.exclude) out = applyExclude(out, qState.exclude);
+				if (!qState.raw) out = applyFormat(out, config.options.format);
+				return out;
+			};
+			return new QueryResult({}, runner);
+		};
+		modelObj.insert = (value) => {
+			const runner = async (mState) => {
+				const table = config.schema[config.tableName];
+				return await execReturn(config.db.insert(table).values(mState.value), mState, config.dialect);
+			};
+			return new MutateResult({
+				kind: "insert",
+				value
+			}, runner);
+		};
+		modelObj.update = (value) => {
+			const runner = async (mState) => {
+				const table = config.schema[config.tableName];
+				const whereSql = compileEffectiveWhere(table, config.options.where, state.where);
+				let q = config.db.update(table).set(mState.value);
+				if (whereSql) q = q.where(whereSql);
+				return await execReturn(q, mState, config.dialect);
+			};
+			return new MutateResult({
+				kind: "update",
+				value
+			}, runner);
+		};
+		modelObj.delete = () => {
+			const runner = async (mState) => {
+				const table = config.schema[config.tableName];
+				const whereSql = compileEffectiveWhere(table, config.options.where, state.where);
+				let q = config.db.delete(table);
+				if (whereSql) q = q.where(whereSql);
+				return await execReturn(q, mState, config.dialect);
+			};
+			return new MutateResult({ kind: "delete" }, runner);
+		};
+		modelObj.upsert = (value) => {
+			const runner = async (mState) => {
+				const table = config.schema[config.tableName];
+				const insertValues = mState.value.insert;
+				const updateCfg = mState.value.update;
+				const target = normalizeUpsertTarget(table, mState.value.target);
+				let updateSet = updateCfg;
+				if (typeof updateCfg === "function") updateSet = updateCfg({
+					excluded: (field) => table[field],
+					inserted: (field) => table[field]
+				});
+				let q = config.db.insert(table).values(insertValues);
+				if (q.onConflictDoUpdate) q = q.onConflictDoUpdate({
+					target,
+					set: updateSet
+				});
+				return await execReturn(q, mState, config.dialect);
+			};
+			return new MutateResult({
+				kind: "upsert",
+				value
+			}, runner);
+		};
+		return modelObj;
+	};
+	return build(baseState);
+}
+
+//#endregion
+export { makeModelRuntime };

package/dist/model/core/thenable.mjs

@@ -0,0 +1,64 @@
+//#region src/model/core/thenable.ts
+var ThenableResult = class {
+	_execute;
+	constructor(execute) {
+		this._execute = execute;
+	}
+	then(onfulfilled, onrejected) {
+		return this._execute().then(onfulfilled, onrejected);
+	}
+};
+var QueryResult = class QueryResult extends ThenableResult {
+	state;
+	runner;
+	constructor(state, runner) {
+		super(() => runner(state));
+		this.state = state;
+		this.runner = runner;
+	}
+	with(value) {
+		return new QueryResult({
+			...this.state,
+			with: value
+		}, this.runner);
+	}
+	select(value) {
+		return new QueryResult({
+			...this.state,
+			select: value
+		}, this.runner);
+	}
+	exclude(value) {
+		return new QueryResult({
+			...this.state,
+			exclude: value
+		}, this.runner);
+	}
+	raw() {
+		return new QueryResult({
+			...this.state,
+			raw: true
+		}, this.runner);
+	}
+	debug() {
+		return this.state;
+	}
+};
+var MutateResult = class MutateResult extends ThenableResult {
+	state;
+	runner;
+	constructor(state, runner) {
+		super(() => runner(state));
+		this.state = state;
+		this.runner = runner;
+	}
+	return(value) {
+		return new MutateResult({
+			...this.state,
+			returnSelect: value
+		}, this.runner);
+	}
+};
+
+//#endregion
+export { MutateResult, QueryResult };

package/dist/model/core/transform.mjs

@@ -0,0 +1,39 @@
+//#region src/model/core/transform.ts
+function applySelect(value, select) {
+	if (value == null) return value;
+	if (Array.isArray(value)) return value.map((v) => applySelect(v, select));
+	if (typeof value !== "object") return value;
+	const out = {};
+	for (const [key, sel] of Object.entries(select)) {
+		if (sel === true) {
+			out[key] = value[key];
+			continue;
+		}
+		if (sel && typeof sel === "object") out[key] = applySelect(value[key], sel);
+	}
+	return out;
+}
+function applyExclude(value, exclude) {
+	if (value == null) return value;
+	if (Array.isArray(value)) return value.map((v) => applyExclude(v, exclude));
+	if (typeof value !== "object") return value;
+	const out = { ...value };
+	for (const [key, ex] of Object.entries(exclude)) {
+		if (ex === true) {
+			delete out[key];
+			continue;
+		}
+		if (ex && typeof ex === "object" && key in out) out[key] = applyExclude(out[key], ex);
+	}
+	return out;
+}
+function applyFormat(value, format) {
+	if (!format) return value;
+	if (value == null) return value;
+	if (Array.isArray(value)) return value.map((v) => applyFormat(v, format));
+	if (typeof value !== "object") return value;
+	return format(value);
+}
+
+//#endregion
+export { applyExclude, applyFormat, applySelect };