semola 0.5.2 → 0.5.3

package/dist/orm/runtime/builders/select.mjs

@@ -0,0 +1,19 @@
+import { serializeSelectInput } from "../../sql/serialize.mjs";
+//#region src/lib/orm/runtime/builders/select.ts
+function mapFindInputToSelect(input) {
+	if (!input) return {};
+	return {
+		where: input.where,
+		include: input.include,
+		orderBy: input.orderBy,
+		limit: input.take,
+		offset: input.skip
+	};
+}
+function createSelectQuery(sql, table, relations, input, dialectAdapter) {
+	return serializeSelectInput(sql, table, relations, input, dialectAdapter);
+}
+//#endregion
+export { createSelectQuery, mapFindInputToSelect };
+
+//# sourceMappingURL=select.mjs.map

package/dist/orm/runtime/builders/select.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"select.mjs","names":[],"sources":["../../../../src/lib/orm/runtime/builders/select.ts"],"sourcesContent":["import type { SQL, TransactionSQL } from \"bun\";\nimport { serializeSelectInput } from \"../../sql/serialize.js\";\nimport type { Table } from \"../../table.js\";\nimport type {\n  ColDefs,\n  DialectAdapter,\n  FindManyInput,\n  RelationDefs,\n  SelectInput,\n} from \"../../types.js\";\n\nexport function mapFindInputToSelect<\n  T extends ColDefs,\n  TRels extends RelationDefs,\n>(input?: FindManyInput<T, TRels>) {\n  if (!input) {\n    return {};\n  }\n\n  return {\n    where: input.where,\n    include: input.include,\n    orderBy: input.orderBy,\n    limit: input.take,\n    offset: input.skip,\n  };\n}\n\nexport function createSelectQuery<\n  T extends ColDefs,\n  TRels extends RelationDefs,\n>(\n  sql: SQL | TransactionSQL,\n  table: Table<T>,\n  relations: TRels,\n  input: SelectInput<T, TRels>,\n  dialectAdapter: DialectAdapter,\n) {\n  return serializeSelectInput(sql, table, relations, input, dialectAdapter);\n}\n"],"mappings":";;AAWA,SAAgB,qBAGd,OAAiC;AACjC,KAAI,CAAC,MACH,QAAO,EAAE;AAGX,QAAO;EACL,OAAO,MAAM;EACb,SAAS,MAAM;EACf,SAAS,MAAM;EACf,OAAO,MAAM;EACb,QAAQ,MAAM;EACf;;AAGH,SAAgB,kBAId,KACA,OACA,WACA,OACA,gBACA;AACA,QAAO,qBAAqB,KAAK,OAAO,WAAW,OAAO,eAAe"}

package/dist/orm/runtime/client.cjs

@@ -0,0 +1,90 @@
+const require_select = require("./builders/select.cjs");
+const require_context = require("./context.cjs");
+const require_utils = require("./utils.cjs");
+const require_index = require("./dialect/index.cjs");
+const require_errors = require("./errors.cjs");
+const require_hydrate = require("./hydrate.cjs");
+const require_rows = require("./rows.cjs");
+//#region src/lib/orm/runtime/client.ts
+function createTableClient(sql, table, relations, dialectAdapter, allTables, allRelations) {
+	const supportsReturning = dialectAdapter.dialect !== "mysql";
+	const normalizeCurrentRows = (rows) => require_rows.normalizeRows(dialectAdapter.dialect, table, rows);
+	const normalizeTargetRows = (targetTable, rows) => require_rows.normalizeRowsForTable(dialectAdapter.dialect, targetTable, rows);
+	const context = require_context.createRuntimeDialectContext({
+		runner: sql,
+		table,
+		relations,
+		dialectAdapter,
+		supportsReturning,
+		normalizeCurrentRows,
+		executeOrThrow: require_errors.executeOrThrow
+	});
+	function insertQuery(input) {
+		if (input.returning === true) return context.insertReturning({
+			...input,
+			returning: true
+		});
+		return context.insert(input);
+	}
+	function updateQuery(input) {
+		if (input.returning === true) return context.updateReturning({
+			...input,
+			returning: true
+		});
+		return context.update(input);
+	}
+	function deleteQuery(input) {
+		if (input.returning === true) return context.deleteReturning({
+			...input,
+			returning: true
+		});
+		return context.deleteByWhere(input);
+	}
+	const hydrateIncludedRelations = require_hydrate.createRelationHydrator({
+		sql,
+		table,
+		relations,
+		allTables,
+		allRelations,
+		normalizeRowsForTable: normalizeTargetRows,
+		executeOrThrow: require_errors.executeOrThrow
+	});
+	const runtimeDialect = require_index.getRuntimeDialect(dialectAdapter.dialect);
+	return {
+		select: context.select,
+		async findMany(input) {
+			return hydrateIncludedRelations(await context.selectRows(require_select.mapFindInputToSelect(input)), input?.include);
+		},
+		async findFirst(input) {
+			const rows = await context.selectRows({
+				...require_select.mapFindInputToSelect(input),
+				limit: 1
+			});
+			if (input?.include) await hydrateIncludedRelations(rows, input.include);
+			return rows[0] ?? null;
+		},
+		async findUnique(input) {
+			return (await context.selectRows({
+				where: require_utils.toWhereInput(input.where),
+				limit: 1
+			}))[0] ?? null;
+		},
+		insert: insertQuery,
+		async create(input) {
+			return runtimeDialect.create(context, input);
+		},
+		async createMany(input) {
+			return runtimeDialect.createMany(context, input);
+		},
+		update: updateQuery,
+		async updateMany(input) {
+			return runtimeDialect.updateMany(context, input);
+		},
+		delete: deleteQuery,
+		async deleteMany(input) {
+			return runtimeDialect.deleteMany(context, input);
+		}
+	};
+}
+//#endregion
+exports.createTableClient = createTableClient;

package/dist/orm/runtime/client.mjs

@@ -0,0 +1,92 @@
+import { mapFindInputToSelect } from "./builders/select.mjs";
+import { createRuntimeDialectContext } from "./context.mjs";
+import { toWhereInput } from "./utils.mjs";
+import { getRuntimeDialect } from "./dialect/index.mjs";
+import { executeOrThrow } from "./errors.mjs";
+import { createRelationHydrator } from "./hydrate.mjs";
+import { normalizeRows, normalizeRowsForTable } from "./rows.mjs";
+//#region src/lib/orm/runtime/client.ts
+function createTableClient(sql, table, relations, dialectAdapter, allTables, allRelations) {
+	const supportsReturning = dialectAdapter.dialect !== "mysql";
+	const normalizeCurrentRows = (rows) => normalizeRows(dialectAdapter.dialect, table, rows);
+	const normalizeTargetRows = (targetTable, rows) => normalizeRowsForTable(dialectAdapter.dialect, targetTable, rows);
+	const context = createRuntimeDialectContext({
+		runner: sql,
+		table,
+		relations,
+		dialectAdapter,
+		supportsReturning,
+		normalizeCurrentRows,
+		executeOrThrow
+	});
+	function insertQuery(input) {
+		if (input.returning === true) return context.insertReturning({
+			...input,
+			returning: true
+		});
+		return context.insert(input);
+	}
+	function updateQuery(input) {
+		if (input.returning === true) return context.updateReturning({
+			...input,
+			returning: true
+		});
+		return context.update(input);
+	}
+	function deleteQuery(input) {
+		if (input.returning === true) return context.deleteReturning({
+			...input,
+			returning: true
+		});
+		return context.deleteByWhere(input);
+	}
+	const hydrateIncludedRelations = createRelationHydrator({
+		sql,
+		table,
+		relations,
+		allTables,
+		allRelations,
+		normalizeRowsForTable: normalizeTargetRows,
+		executeOrThrow
+	});
+	const runtimeDialect = getRuntimeDialect(dialectAdapter.dialect);
+	return {
+		select: context.select,
+		async findMany(input) {
+			return hydrateIncludedRelations(await context.selectRows(mapFindInputToSelect(input)), input?.include);
+		},
+		async findFirst(input) {
+			const rows = await context.selectRows({
+				...mapFindInputToSelect(input),
+				limit: 1
+			});
+			if (input?.include) await hydrateIncludedRelations(rows, input.include);
+			return rows[0] ?? null;
+		},
+		async findUnique(input) {
+			return (await context.selectRows({
+				where: toWhereInput(input.where),
+				limit: 1
+			}))[0] ?? null;
+		},
+		insert: insertQuery,
+		async create(input) {
+			return runtimeDialect.create(context, input);
+		},
+		async createMany(input) {
+			return runtimeDialect.createMany(context, input);
+		},
+		update: updateQuery,
+		async updateMany(input) {
+			return runtimeDialect.updateMany(context, input);
+		},
+		delete: deleteQuery,
+		async deleteMany(input) {
+			return runtimeDialect.deleteMany(context, input);
+		}
+	};
+}
+//#endregion
+export { createTableClient };
+
+//# sourceMappingURL=client.mjs.map

package/dist/orm/runtime/client.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.mjs","names":[],"sources":["../../../src/lib/orm/runtime/client.ts"],"sourcesContent":["import type { SQL, TransactionSQL } from \"bun\";\nimport type { Table } from \"../table.js\";\nimport type {\n  ColDefs,\n  CreateInput,\n  CreateManyInput,\n  DeleteBuilderInput,\n  DeleteManyInput,\n  DialectAdapter,\n  FindFirstInput,\n  FindManyInput,\n  FindUniqueInput,\n  InsertInput,\n  RelationDefs,\n  TableRow,\n  TinyTableClient,\n  UpdateBuilderInput,\n  UpdateManyInput,\n} from \"../types.js\";\nimport { mapFindInputToSelect } from \"./builders.js\";\nimport { createRuntimeDialectContext } from \"./context.js\";\nimport { getRuntimeDialect } from \"./dialect/index.js\";\nimport { executeOrThrow } from \"./errors.js\";\nimport { createRelationHydrator } from \"./hydrate.js\";\nimport { normalizeRows, normalizeRowsForTable } from \"./rows.js\";\nimport { toWhereInput } from \"./utils.js\";\n\nexport function createTableClient<\n  T extends ColDefs,\n  TRels extends RelationDefs,\n>(\n  sql: SQL | TransactionSQL,\n  table: Table<T>,\n  relations: TRels,\n  dialectAdapter: DialectAdapter,\n  allTables: Record<string, Table<ColDefs>>,\n  allRelations: Partial<Record<string, RelationDefs>>,\n): TinyTableClient<T, TRels> {\n  const supportsReturning = dialectAdapter.dialect !== \"mysql\";\n\n  const normalizeCurrentRows = (rows: TableRow<T>[]) =>\n    normalizeRows(dialectAdapter.dialect, table, rows);\n\n  const normalizeTargetRows = (\n    targetTable: Table<ColDefs>,\n    rows: Record<string, unknown>[],\n  ) => normalizeRowsForTable(dialectAdapter.dialect, targetTable, rows);\n\n  const context = createRuntimeDialectContext({\n    runner: sql,\n    table,\n    relations,\n    dialectAdapter,\n    supportsReturning,\n    normalizeCurrentRows,\n    executeOrThrow,\n  });\n\n  function insertQuery(\n    input: InsertInput<T> & { returning: true },\n  ): SQL.Query<TableRow<T>[]>;\n  function insertQuery(input: InsertInput<T>): SQL.Query<unknown>;\n  function insertQuery(input: InsertInput<T>) {\n    if (input.returning === true) {\n      return context.insertReturning({ ...input, returning: true });\n    }\n\n    return context.insert(input);\n  }\n\n  function updateQuery(\n    input: UpdateBuilderInput<T> & { returning: true },\n  ): SQL.Query<TableRow<T>[]>;\n  function updateQuery(input: UpdateBuilderInput<T>): SQL.Query<unknown>;\n  function updateQuery(input: UpdateBuilderInput<T>) {\n    if (input.returning === true) {\n      return context.updateReturning({ ...input, returning: true });\n    }\n\n    return context.update(input);\n  }\n\n  function deleteQuery(\n    input: DeleteBuilderInput<T> & { returning: true },\n  ): SQL.Query<TableRow<T>[]>;\n  function deleteQuery(input: DeleteBuilderInput<T>): SQL.Query<unknown>;\n  function deleteQuery(input: DeleteBuilderInput<T>) {\n    if (input.returning === true) {\n      return context.deleteReturning({ ...input, returning: true });\n    }\n\n    return context.deleteByWhere(input);\n  }\n\n  const hydrateIncludedRelations = createRelationHydrator({\n    sql,\n    table,\n    relations,\n    allTables,\n    allRelations,\n    normalizeRowsForTable: normalizeTargetRows,\n    executeOrThrow,\n  });\n\n  const runtimeDialect = getRuntimeDialect<T, TRels>(dialectAdapter.dialect);\n\n  return {\n    select: context.select,\n\n    async findMany(input?: FindManyInput<T, TRels>) {\n      const rows = await context.selectRows(mapFindInputToSelect(input));\n      return hydrateIncludedRelations(rows, input?.include);\n    },\n\n    async findFirst(input?: FindFirstInput<T, TRels>) {\n      const rows = await context.selectRows({\n        ...mapFindInputToSelect(input),\n        limit: 1,\n      });\n\n      if (input?.include) {\n        await hydrateIncludedRelations(rows, input.include);\n      }\n\n      return rows[0] ?? null;\n    },\n\n    async findUnique(input: FindUniqueInput<T>) {\n      const rows = await context.selectRows({\n        where: toWhereInput<T>(input.where) as FindManyInput<\n          T,\n          Record<never, never>\n        >[\"where\"],\n        limit: 1,\n      });\n      return rows[0] ?? null;\n    },\n\n    insert: insertQuery,\n\n    async create(input: CreateInput<T>) {\n      return runtimeDialect.create(context, input);\n    },\n\n    async createMany(input: CreateManyInput<T>) {\n      return runtimeDialect.createMany(context, input);\n    },\n\n    update: updateQuery,\n\n    async updateMany(input: UpdateManyInput<T>) {\n      return runtimeDialect.updateMany(context, input);\n    },\n\n    delete: deleteQuery,\n\n    async deleteMany(input: DeleteManyInput<T>) {\n      return runtimeDialect.deleteMany(context, input);\n    },\n  };\n}\n"],"mappings":";;;;;;;;AA2BA,SAAgB,kBAId,KACA,OACA,WACA,gBACA,WACA,cAC2B;CAC3B,MAAM,oBAAoB,eAAe,YAAY;CAErD,MAAM,wBAAwB,SAC5B,cAAc,eAAe,SAAS,OAAO,KAAK;CAEpD,MAAM,uBACJ,aACA,SACG,sBAAsB,eAAe,SAAS,aAAa,KAAK;CAErE,MAAM,UAAU,4BAA4B;EAC1C,QAAQ;EACR;EACA;EACA;EACA;EACA;EACA;EACD,CAAC;CAMF,SAAS,YAAY,OAAuB;AAC1C,MAAI,MAAM,cAAc,KACtB,QAAO,QAAQ,gBAAgB;GAAE,GAAG;GAAO,WAAW;GAAM,CAAC;AAG/D,SAAO,QAAQ,OAAO,MAAM;;CAO9B,SAAS,YAAY,OAA8B;AACjD,MAAI,MAAM,cAAc,KACtB,QAAO,QAAQ,gBAAgB;GAAE,GAAG;GAAO,WAAW;GAAM,CAAC;AAG/D,SAAO,QAAQ,OAAO,MAAM;;CAO9B,SAAS,YAAY,OAA8B;AACjD,MAAI,MAAM,cAAc,KACtB,QAAO,QAAQ,gBAAgB;GAAE,GAAG;GAAO,WAAW;GAAM,CAAC;AAG/D,SAAO,QAAQ,cAAc,MAAM;;CAGrC,MAAM,2BAA2B,uBAAuB;EACtD;EACA;EACA;EACA;EACA;EACA,uBAAuB;EACvB;EACD,CAAC;CAEF,MAAM,iBAAiB,kBAA4B,eAAe,QAAQ;AAE1E,QAAO;EACL,QAAQ,QAAQ;EAEhB,MAAM,SAAS,OAAiC;AAE9C,UAAO,yBADM,MAAM,QAAQ,WAAW,qBAAqB,MAAM,CAAC,EAC5B,OAAO,QAAQ;;EAGvD,MAAM,UAAU,OAAkC;GAChD,MAAM,OAAO,MAAM,QAAQ,WAAW;IACpC,GAAG,qBAAqB,MAAM;IAC9B,OAAO;IACR,CAAC;AAEF,OAAI,OAAO,QACT,OAAM,yBAAyB,MAAM,MAAM,QAAQ;AAGrD,UAAO,KAAK,MAAM;;EAGpB,MAAM,WAAW,OAA2B;AAQ1C,WAPa,MAAM,QAAQ,WAAW;IACpC,OAAO,aAAgB,MAAM,MAAM;IAInC,OAAO;IACR,CAAC,EACU,MAAM;;EAGpB,QAAQ;EAER,MAAM,OAAO,OAAuB;AAClC,UAAO,eAAe,OAAO,SAAS,MAAM;;EAG9C,MAAM,WAAW,OAA2B;AAC1C,UAAO,eAAe,WAAW,SAAS,MAAM;;EAGlD,QAAQ;EAER,MAAM,WAAW,OAA2B;AAC1C,UAAO,eAAe,WAAW,SAAS,MAAM;;EAGlD,QAAQ;EAER,MAAM,WAAW,OAA2B;AAC1C,UAAO,eAAe,WAAW,SAAS,MAAM;;EAEnD"}

package/dist/orm/runtime/context.cjs

@@ -0,0 +1,49 @@
+const require_values = require("../sql/serialize/values.cjs");
+const require_mutations = require("./builders/mutations.cjs");
+const require_select = require("./builders/select.cjs");
+//#region src/lib/orm/runtime/context.ts
+function createRuntimeDialectContext(options) {
+	const { runner, table, relations, dialectAdapter, supportsReturning, normalizeCurrentRows, executeOrThrow } = options;
+	const withRunner = (nextRunner) => createRuntimeDialectContext({
+		runner: nextRunner,
+		table,
+		relations,
+		dialectAdapter,
+		supportsReturning,
+		normalizeCurrentRows,
+		executeOrThrow
+	});
+	const select = (input = {}) => require_select.createSelectQuery(runner, table, relations, input, dialectAdapter);
+	const insert = (input) => require_mutations.createInsertQuery(runner, table, input, dialectAdapter, supportsReturning);
+	const insertReturning = (input) => require_mutations.createInsertQuery(runner, table, input, dialectAdapter, supportsReturning);
+	const insertMany = (rows, returning) => require_mutations.createInsertManyQuery(runner, table, rows, supportsReturning && returning);
+	const insertManyReturning = (rows) => require_mutations.createInsertManyQuery(runner, table, rows, true);
+	const update = (input) => require_mutations.createUpdateQuery(runner, table, input, dialectAdapter, supportsReturning);
+	const updateReturning = (input) => require_mutations.createUpdateQuery(runner, table, input, dialectAdapter, supportsReturning);
+	const deleteByWhere = (input) => require_mutations.createDeleteQuery(runner, table, input, dialectAdapter, supportsReturning);
+	const deleteReturning = (input) => require_mutations.createDeleteQuery(runner, table, input, dialectAdapter, supportsReturning);
+	const selectRows = async (input = {}) => {
+		return normalizeCurrentRows(await executeOrThrow(select(input)));
+	};
+	return {
+		runner,
+		table,
+		relations,
+		select,
+		selectRows,
+		insert,
+		insertReturning,
+		insertMany,
+		insertManyReturning,
+		update,
+		updateReturning,
+		deleteByWhere,
+		deleteReturning,
+		mapSqlRow: (data) => require_values.mapDataToSqlRow(table, data, dialectAdapter),
+		normalizeResultRows: normalizeCurrentRows,
+		executeOrThrow,
+		withRunner
+	};
+}
+//#endregion
+exports.createRuntimeDialectContext = createRuntimeDialectContext;

package/dist/orm/runtime/context.mjs

@@ -0,0 +1,51 @@
+import { mapDataToSqlRow } from "../sql/serialize/values.mjs";
+import { createDeleteQuery, createInsertManyQuery, createInsertQuery, createUpdateQuery } from "./builders/mutations.mjs";
+import { createSelectQuery } from "./builders/select.mjs";
+//#region src/lib/orm/runtime/context.ts
+function createRuntimeDialectContext(options) {
+	const { runner, table, relations, dialectAdapter, supportsReturning, normalizeCurrentRows, executeOrThrow } = options;
+	const withRunner = (nextRunner) => createRuntimeDialectContext({
+		runner: nextRunner,
+		table,
+		relations,
+		dialectAdapter,
+		supportsReturning,
+		normalizeCurrentRows,
+		executeOrThrow
+	});
+	const select = (input = {}) => createSelectQuery(runner, table, relations, input, dialectAdapter);
+	const insert = (input) => createInsertQuery(runner, table, input, dialectAdapter, supportsReturning);
+	const insertReturning = (input) => createInsertQuery(runner, table, input, dialectAdapter, supportsReturning);
+	const insertMany = (rows, returning) => createInsertManyQuery(runner, table, rows, supportsReturning && returning);
+	const insertManyReturning = (rows) => createInsertManyQuery(runner, table, rows, true);
+	const update = (input) => createUpdateQuery(runner, table, input, dialectAdapter, supportsReturning);
+	const updateReturning = (input) => createUpdateQuery(runner, table, input, dialectAdapter, supportsReturning);
+	const deleteByWhere = (input) => createDeleteQuery(runner, table, input, dialectAdapter, supportsReturning);
+	const deleteReturning = (input) => createDeleteQuery(runner, table, input, dialectAdapter, supportsReturning);
+	const selectRows = async (input = {}) => {
+		return normalizeCurrentRows(await executeOrThrow(select(input)));
+	};
+	return {
+		runner,
+		table,
+		relations,
+		select,
+		selectRows,
+		insert,
+		insertReturning,
+		insertMany,
+		insertManyReturning,
+		update,
+		updateReturning,
+		deleteByWhere,
+		deleteReturning,
+		mapSqlRow: (data) => mapDataToSqlRow(table, data, dialectAdapter),
+		normalizeResultRows: normalizeCurrentRows,
+		executeOrThrow,
+		withRunner
+	};
+}
+//#endregion
+export { createRuntimeDialectContext };
+
+//# sourceMappingURL=context.mjs.map

package/dist/orm/runtime/context.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.mjs","names":[],"sources":["../../../src/lib/orm/runtime/context.ts"],"sourcesContent":["import type { SQL, TransactionSQL } from \"bun\";\nimport { mapDataToSqlRow } from \"../sql/serialize.js\";\nimport type { Table } from \"../table.js\";\nimport type {\n  ColDefs,\n  DeleteBuilderInput,\n  DialectAdapter,\n  InsertInput,\n  RelationDefs,\n  TableRow,\n  UpdateBuilderInput,\n} from \"../types.js\";\nimport {\n  createDeleteQuery,\n  createInsertManyQuery,\n  createInsertQuery,\n  createSelectQuery,\n  createUpdateQuery,\n} from \"./builders.js\";\nimport type { RuntimeDialectContext } from \"./dialect/types.js\";\n\nexport function createRuntimeDialectContext<\n  T extends ColDefs,\n  TRels extends RelationDefs,\n>(options: {\n  runner: SQL | TransactionSQL;\n  table: Table<T>;\n  relations: TRels;\n  dialectAdapter: DialectAdapter;\n  supportsReturning: boolean;\n  normalizeCurrentRows: (rows: TableRow<T>[]) => TableRow<T>[];\n  executeOrThrow: <TValue>(promise: Promise<TValue>) => Promise<TValue>;\n}) {\n  const {\n    runner,\n    table,\n    relations,\n    dialectAdapter,\n    supportsReturning,\n    normalizeCurrentRows,\n    executeOrThrow,\n  } = options;\n\n  const withRunner = (nextRunner: SQL | TransactionSQL) =>\n    createRuntimeDialectContext({\n      runner: nextRunner,\n      table,\n      relations,\n      dialectAdapter,\n      supportsReturning,\n      normalizeCurrentRows,\n      executeOrThrow,\n    });\n\n  const select = (input = {}) =>\n    createSelectQuery(runner, table, relations, input, dialectAdapter);\n\n  const insert = (input: InsertInput<T>) =>\n    createInsertQuery(runner, table, input, dialectAdapter, supportsReturning);\n\n  const insertReturning = (input: InsertInput<T> & { returning: true }) =>\n    createInsertQuery(runner, table, input, dialectAdapter, supportsReturning);\n\n  const insertMany = (\n    rows: Array<Record<string, unknown>>,\n    returning: boolean,\n  ) =>\n    createInsertManyQuery(runner, table, rows, supportsReturning && returning);\n\n  const insertManyReturning = (rows: Array<Record<string, unknown>>) =>\n    createInsertManyQuery(runner, table, rows, true);\n\n  const update = (input: UpdateBuilderInput<T>) =>\n    createUpdateQuery(runner, table, input, dialectAdapter, supportsReturning);\n\n  const updateReturning = (\n    input: UpdateBuilderInput<T> & { returning: true },\n  ) =>\n    createUpdateQuery(runner, table, input, dialectAdapter, supportsReturning);\n\n  const deleteByWhere = (input: DeleteBuilderInput<T>) =>\n    createDeleteQuery(runner, table, input, dialectAdapter, supportsReturning);\n\n  const deleteReturning = (\n    input: DeleteBuilderInput<T> & { returning: true },\n  ) =>\n    createDeleteQuery(runner, table, input, dialectAdapter, supportsReturning);\n\n  const selectRows = async (input = {}) => {\n    const rows = await executeOrThrow(select(input));\n    return normalizeCurrentRows(rows);\n  };\n\n  const context: RuntimeDialectContext<T, TRels> = {\n    runner,\n    table,\n    relations,\n    select,\n    selectRows,\n    insert,\n    insertReturning,\n    insertMany,\n    insertManyReturning,\n    update,\n    updateReturning,\n    deleteByWhere,\n    deleteReturning,\n    mapSqlRow: (data) => mapDataToSqlRow(table, data, dialectAdapter),\n    normalizeResultRows: normalizeCurrentRows,\n    executeOrThrow,\n    withRunner,\n  };\n\n  return context;\n}\n"],"mappings":";;;;AAqBA,SAAgB,4BAGd,SAQC;CACD,MAAM,EACJ,QACA,OACA,WACA,gBACA,mBACA,sBACA,mBACE;CAEJ,MAAM,cAAc,eAClB,4BAA4B;EAC1B,QAAQ;EACR;EACA;EACA;EACA;EACA;EACA;EACD,CAAC;CAEJ,MAAM,UAAU,QAAQ,EAAE,KACxB,kBAAkB,QAAQ,OAAO,WAAW,OAAO,eAAe;CAEpE,MAAM,UAAU,UACd,kBAAkB,QAAQ,OAAO,OAAO,gBAAgB,kBAAkB;CAE5E,MAAM,mBAAmB,UACvB,kBAAkB,QAAQ,OAAO,OAAO,gBAAgB,kBAAkB;CAE5E,MAAM,cACJ,MACA,cAEA,sBAAsB,QAAQ,OAAO,MAAM,qBAAqB,UAAU;CAE5E,MAAM,uBAAuB,SAC3B,sBAAsB,QAAQ,OAAO,MAAM,KAAK;CAElD,MAAM,UAAU,UACd,kBAAkB,QAAQ,OAAO,OAAO,gBAAgB,kBAAkB;CAE5E,MAAM,mBACJ,UAEA,kBAAkB,QAAQ,OAAO,OAAO,gBAAgB,kBAAkB;CAE5E,MAAM,iBAAiB,UACrB,kBAAkB,QAAQ,OAAO,OAAO,gBAAgB,kBAAkB;CAE5E,MAAM,mBACJ,UAEA,kBAAkB,QAAQ,OAAO,OAAO,gBAAgB,kBAAkB;CAE5E,MAAM,aAAa,OAAO,QAAQ,EAAE,KAAK;AAEvC,SAAO,qBADM,MAAM,eAAe,OAAO,MAAM,CAAC,CACf;;AAuBnC,QApBiD;EAC/C;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,YAAY,SAAS,gBAAgB,OAAO,MAAM,eAAe;EACjE,qBAAqB;EACrB;EACA;EACD"}

package/dist/orm/runtime/dialect/index.cjs

@@ -0,0 +1,11 @@
+const require_mysql = require("./mysql.cjs");
+const require_postgres = require("./postgres.cjs");
+const require_sqlite = require("./sqlite.cjs");
+//#region src/lib/orm/runtime/dialect/index.ts
+function getRuntimeDialect(dialect) {
+	if (dialect === "postgres") return require_postgres.createPostgresRuntimeDialect();
+	if (dialect === "mysql") return require_mysql.createMysqlRuntimeDialect();
+	return require_sqlite.createSqliteRuntimeDialect();
+}
+//#endregion
+exports.getRuntimeDialect = getRuntimeDialect;

package/dist/orm/runtime/dialect/index.mjs

@@ -0,0 +1,13 @@
+import { createMysqlRuntimeDialect } from "./mysql.mjs";
+import { createPostgresRuntimeDialect } from "./postgres.mjs";
+import { createSqliteRuntimeDialect } from "./sqlite.mjs";
+//#region src/lib/orm/runtime/dialect/index.ts
+function getRuntimeDialect(dialect) {
+	if (dialect === "postgres") return createPostgresRuntimeDialect();
+	if (dialect === "mysql") return createMysqlRuntimeDialect();
+	return createSqliteRuntimeDialect();
+}
+//#endregion
+export { getRuntimeDialect };
+
+//# sourceMappingURL=index.mjs.map

package/dist/orm/runtime/dialect/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../../src/lib/orm/runtime/dialect/index.ts"],"sourcesContent":["import type { ColDefs, Dialect, RelationDefs } from \"../../types.js\";\nimport { createMysqlRuntimeDialect } from \"./mysql.js\";\nimport { createPostgresRuntimeDialect } from \"./postgres.js\";\nimport { createSqliteRuntimeDialect } from \"./sqlite.js\";\n\nexport function getRuntimeDialect<\n  T extends ColDefs,\n  TRels extends RelationDefs,\n>(dialect: Dialect) {\n  if (dialect === \"postgres\") {\n    return createPostgresRuntimeDialect<T, TRels>();\n  }\n\n  if (dialect === \"mysql\") {\n    return createMysqlRuntimeDialect<T, TRels>();\n  }\n\n  return createSqliteRuntimeDialect<T, TRels>();\n}\n"],"mappings":";;;;AAKA,SAAgB,kBAGd,SAAkB;AAClB,KAAI,YAAY,WACd,QAAO,8BAAwC;AAGjD,KAAI,YAAY,QACd,QAAO,2BAAqC;AAG9C,QAAO,4BAAsC"}

package/dist/orm/runtime/dialect/mysql.cjs

@@ -0,0 +1,95 @@
+const require_table_lookup = require("../../internal/table-lookup.cjs");
+const require_utils = require("../utils.cjs");
+let bun = require("bun");
+//#region src/lib/orm/runtime/dialect/mysql.ts
+function createMysqlRuntimeDialect() {
+	return {
+		async create(context, input) {
+			const primaryKey = require_table_lookup.getPrimaryKeyColumn(context.table);
+			const selectCreatedRow = async (whereData) => {
+				return require_utils.expectSingleRow(await context.selectRows({
+					where: require_utils.toWhereInput(whereData),
+					limit: 1
+				}), "Insert returned no rows");
+			};
+			const selectLastInsertId = async () => {
+				const rows = await context.executeOrThrow(context.runner`SELECT LAST_INSERT_ID() AS insertId`);
+				if (!Array.isArray(rows)) return;
+				const firstRow = rows[0];
+				if (typeof firstRow !== "object") return;
+				if (firstRow === null) return;
+				return Reflect.get(firstRow, "insertId");
+			};
+			const insertResult = await context.executeOrThrow(context.insert({ data: input.data }));
+			if (!primaryKey) return selectCreatedRow(input.data);
+			const selectCreatedRowByPrimaryKey = async (value) => {
+				const whereByPk = {};
+				Reflect.set(whereByPk, primaryKey.jsKey, value);
+				return selectCreatedRow(whereByPk);
+			};
+			const providedPkValue = Reflect.get(input.data, primaryKey.jsKey);
+			if (providedPkValue !== null && providedPkValue !== void 0) return selectCreatedRowByPrimaryKey(providedPkValue);
+			let insertedPkValue;
+			if (typeof insertResult === "object") {
+				if (insertResult !== null) insertedPkValue = Reflect.get(insertResult, "insertId");
+			}
+			if (insertedPkValue === null || insertedPkValue === void 0) insertedPkValue = await selectLastInsertId();
+			if (insertedPkValue === null || insertedPkValue === void 0) throw new Error("Insert returned no primary key");
+			return selectCreatedRowByPrimaryKey(insertedPkValue);
+		},
+		async createMany(context, input) {
+			if (input.data.length === 0) return {
+				count: 0,
+				rows: []
+			};
+			const rows = input.data.map((item) => context.mapSqlRow(item));
+			await context.executeOrThrow(context.insertMany(rows, false));
+			return {
+				count: rows.length,
+				rows: []
+			};
+		},
+		async updateMany(context, input) {
+			if (context.runner instanceof bun.SQL) return context.executeOrThrow(context.runner.begin(async (tx) => {
+				const txContext = context.withRunner(tx);
+				const beforeRows = await txContext.selectRows({ where: input.where });
+				await txContext.executeOrThrow(txContext.update({
+					where: input.where,
+					data: input.data
+				}));
+				return {
+					count: beforeRows.length,
+					rows: require_utils.mergeRows(beforeRows, input.data)
+				};
+			}));
+			const beforeRows = await context.selectRows({ where: input.where });
+			await context.executeOrThrow(context.update({
+				where: input.where,
+				data: input.data
+			}));
+			return {
+				count: beforeRows.length,
+				rows: require_utils.mergeRows(beforeRows, input.data)
+			};
+		},
+		async deleteMany(context, input) {
+			if (context.runner instanceof bun.SQL) return context.executeOrThrow(context.runner.begin(async (tx) => {
+				const txContext = context.withRunner(tx);
+				const beforeRows = await txContext.selectRows({ where: input.where });
+				await txContext.executeOrThrow(txContext.deleteByWhere({ where: input.where }));
+				return {
+					count: beforeRows.length,
+					rows: beforeRows
+				};
+			}));
+			const rows = await context.selectRows({ where: input.where });
+			await context.executeOrThrow(context.deleteByWhere({ where: input.where }));
+			return {
+				count: rows.length,
+				rows
+			};
+		}
+	};
+}
+//#endregion
+exports.createMysqlRuntimeDialect = createMysqlRuntimeDialect;

package/dist/orm/runtime/dialect/mysql.mjs

@@ -0,0 +1,97 @@
+import { getPrimaryKeyColumn } from "../../internal/table-lookup.mjs";
+import { expectSingleRow, mergeRows, toWhereInput } from "../utils.mjs";
+import { SQL } from "bun";
+//#region src/lib/orm/runtime/dialect/mysql.ts
+function createMysqlRuntimeDialect() {
+	return {
+		async create(context, input) {
+			const primaryKey = getPrimaryKeyColumn(context.table);
+			const selectCreatedRow = async (whereData) => {
+				return expectSingleRow(await context.selectRows({
+					where: toWhereInput(whereData),
+					limit: 1
+				}), "Insert returned no rows");
+			};
+			const selectLastInsertId = async () => {
+				const rows = await context.executeOrThrow(context.runner`SELECT LAST_INSERT_ID() AS insertId`);
+				if (!Array.isArray(rows)) return;
+				const firstRow = rows[0];
+				if (typeof firstRow !== "object") return;
+				if (firstRow === null) return;
+				return Reflect.get(firstRow, "insertId");
+			};
+			const insertResult = await context.executeOrThrow(context.insert({ data: input.data }));
+			if (!primaryKey) return selectCreatedRow(input.data);
+			const selectCreatedRowByPrimaryKey = async (value) => {
+				const whereByPk = {};
+				Reflect.set(whereByPk, primaryKey.jsKey, value);
+				return selectCreatedRow(whereByPk);
+			};
+			const providedPkValue = Reflect.get(input.data, primaryKey.jsKey);
+			if (providedPkValue !== null && providedPkValue !== void 0) return selectCreatedRowByPrimaryKey(providedPkValue);
+			let insertedPkValue;
+			if (typeof insertResult === "object") {
+				if (insertResult !== null) insertedPkValue = Reflect.get(insertResult, "insertId");
+			}
+			if (insertedPkValue === null || insertedPkValue === void 0) insertedPkValue = await selectLastInsertId();
+			if (insertedPkValue === null || insertedPkValue === void 0) throw new Error("Insert returned no primary key");
+			return selectCreatedRowByPrimaryKey(insertedPkValue);
+		},
+		async createMany(context, input) {
+			if (input.data.length === 0) return {
+				count: 0,
+				rows: []
+			};
+			const rows = input.data.map((item) => context.mapSqlRow(item));
+			await context.executeOrThrow(context.insertMany(rows, false));
+			return {
+				count: rows.length,
+				rows: []
+			};
+		},
+		async updateMany(context, input) {
+			if (context.runner instanceof SQL) return context.executeOrThrow(context.runner.begin(async (tx) => {
+				const txContext = context.withRunner(tx);
+				const beforeRows = await txContext.selectRows({ where: input.where });
+				await txContext.executeOrThrow(txContext.update({
+					where: input.where,
+					data: input.data
+				}));
+				return {
+					count: beforeRows.length,
+					rows: mergeRows(beforeRows, input.data)
+				};
+			}));
+			const beforeRows = await context.selectRows({ where: input.where });
+			await context.executeOrThrow(context.update({
+				where: input.where,
+				data: input.data
+			}));
+			return {
+				count: beforeRows.length,
+				rows: mergeRows(beforeRows, input.data)
+			};
+		},
+		async deleteMany(context, input) {
+			if (context.runner instanceof SQL) return context.executeOrThrow(context.runner.begin(async (tx) => {
+				const txContext = context.withRunner(tx);
+				const beforeRows = await txContext.selectRows({ where: input.where });
+				await txContext.executeOrThrow(txContext.deleteByWhere({ where: input.where }));
+				return {
+					count: beforeRows.length,
+					rows: beforeRows
+				};
+			}));
+			const rows = await context.selectRows({ where: input.where });
+			await context.executeOrThrow(context.deleteByWhere({ where: input.where }));
+			return {
+				count: rows.length,
+				rows
+			};
+		}
+	};
+}
+//#endregion
+export { createMysqlRuntimeDialect };
+
+//# sourceMappingURL=mysql.mjs.map

package/dist/orm/runtime/dialect/mysql.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mysql.mjs","names":[],"sources":["../../../../src/lib/orm/runtime/dialect/mysql.ts"],"sourcesContent":["import { SQL } from \"bun\";\nimport { getPrimaryKeyColumn } from \"../../internal/table.js\";\nimport type { ColDefs, RelationDefs } from \"../../types.js\";\nimport type { RuntimeDialect } from \"./types.js\";\nimport { expectSingleRow, mergeRows, toWhereInput } from \"./utils.js\";\n\nexport function createMysqlRuntimeDialect<\n  T extends ColDefs,\n  TRels extends RelationDefs,\n>(): RuntimeDialect<T, TRels> {\n  return {\n    async create(context, input) {\n      const primaryKey = getPrimaryKeyColumn(context.table);\n\n      const selectCreatedRow = async (whereData: Record<string, unknown>) => {\n        const rows = await context.selectRows({\n          where: toWhereInput<T>(whereData),\n          limit: 1,\n        });\n\n        return expectSingleRow(rows, \"Insert returned no rows\");\n      };\n\n      const selectLastInsertId = async () => {\n        const rows = await context.executeOrThrow(\n          context.runner`SELECT LAST_INSERT_ID() AS insertId`,\n        );\n\n        if (!Array.isArray(rows)) {\n          return undefined;\n        }\n\n        const firstRow = rows[0];\n\n        if (typeof firstRow !== \"object\") {\n          return undefined;\n        }\n\n        if (firstRow === null) {\n          return undefined;\n        }\n\n        return Reflect.get(firstRow, \"insertId\");\n      };\n\n      const insertResult = await context.executeOrThrow(\n        context.insert({ data: input.data }),\n      );\n\n      if (!primaryKey) {\n        return selectCreatedRow(input.data);\n      }\n\n      const selectCreatedRowByPrimaryKey = async (value: unknown) => {\n        const whereByPk: Record<string, unknown> = {};\n        Reflect.set(whereByPk, primaryKey.jsKey, value);\n\n        return selectCreatedRow(whereByPk);\n      };\n\n      const providedPkValue = Reflect.get(input.data, primaryKey.jsKey);\n\n      if (providedPkValue !== null && providedPkValue !== undefined) {\n        return selectCreatedRowByPrimaryKey(providedPkValue);\n      }\n\n      let insertedPkValue: unknown;\n\n      if (typeof insertResult === \"object\") {\n        if (insertResult !== null) {\n          insertedPkValue = Reflect.get(insertResult, \"insertId\");\n        }\n      }\n\n      if (insertedPkValue === null || insertedPkValue === undefined) {\n        insertedPkValue = await selectLastInsertId();\n      }\n\n      if (insertedPkValue === null || insertedPkValue === undefined) {\n        throw new Error(\"Insert returned no primary key\");\n      }\n\n      return selectCreatedRowByPrimaryKey(insertedPkValue);\n    },\n\n    async createMany(context, input) {\n      if (input.data.length === 0) {\n        return { count: 0, rows: [] };\n      }\n\n      const rows = input.data.map((item) =>\n        context.mapSqlRow(item as Record<string, unknown>),\n      );\n\n      await context.executeOrThrow(context.insertMany(rows, false));\n\n      return {\n        count: rows.length,\n        rows: [],\n      };\n    },\n\n    async updateMany(context, input) {\n      if (context.runner instanceof SQL) {\n        return context.executeOrThrow(\n          context.runner.begin(async (tx) => {\n            const txContext = context.withRunner(tx);\n            const beforeRows = await txContext.selectRows({\n              where: input.where,\n            });\n\n            await txContext.executeOrThrow(\n              txContext.update({ where: input.where, data: input.data }),\n            );\n\n            return {\n              count: beforeRows.length,\n              rows: mergeRows(\n                beforeRows,\n                input.data as Partial<Record<string, unknown>>,\n              ),\n            };\n          }),\n        );\n      }\n\n      const beforeRows = await context.selectRows({ where: input.where });\n\n      await context.executeOrThrow(\n        context.update({ where: input.where, data: input.data }),\n      );\n\n      return {\n        count: beforeRows.length,\n        rows: mergeRows(\n          beforeRows,\n          input.data as Partial<Record<string, unknown>>,\n        ),\n      };\n    },\n\n    async deleteMany(context, input) {\n      if (context.runner instanceof SQL) {\n        return context.executeOrThrow(\n          context.runner.begin(async (tx) => {\n            const txContext = context.withRunner(tx);\n            const beforeRows = await txContext.selectRows({\n              where: input.where,\n            });\n\n            await txContext.executeOrThrow(\n              txContext.deleteByWhere({ where: input.where }),\n            );\n\n            return {\n              count: beforeRows.length,\n              rows: beforeRows,\n            };\n          }),\n        );\n      }\n\n      const rows = await context.selectRows({ where: input.where });\n\n      await context.executeOrThrow(\n        context.deleteByWhere({ where: input.where }),\n      );\n\n      return {\n        count: rows.length,\n        rows,\n      };\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/orm/runtime/dialect/postgres.cjs

@@ -0,0 +1,51 @@
+const require_utils = require("../utils.cjs");
+//#region src/lib/orm/runtime/dialect/postgres.ts
+function createPostgresRuntimeDialect() {
+	return {
+		async create(context, input) {
+			const rows = await context.executeOrThrow(context.insertReturning({
+				data: input.data,
+				returning: true
+			}));
+			return require_utils.expectSingleRow(context.normalizeResultRows(rows), "Insert returned no rows");
+		},
+		async createMany(context, input) {
+			if (input.data.length === 0) return {
+				count: 0,
+				rows: []
+			};
+			const rows = input.data.map((item) => context.mapSqlRow(item));
+			const createdRows = await context.executeOrThrow(context.insertManyReturning(rows));
+			const normalizedRows = context.normalizeResultRows(createdRows);
+			return {
+				count: normalizedRows.length,
+				rows: normalizedRows
+			};
+		},
+		async updateMany(context, input) {
+			const rows = await context.executeOrThrow(context.updateReturning({
+				where: input.where,
+				data: input.data,
+				returning: true
+			}));
+			const normalizedRows = context.normalizeResultRows(rows);
+			return {
+				count: normalizedRows.length,
+				rows: normalizedRows
+			};
+		},
+		async deleteMany(context, input) {
+			const rows = await context.executeOrThrow(context.deleteReturning({
+				where: input.where,
+				returning: true
+			}));
+			const normalizedRows = context.normalizeResultRows(rows);
+			return {
+				count: normalizedRows.length,
+				rows: normalizedRows
+			};
+		}
+	};
+}
+//#endregion
+exports.createPostgresRuntimeDialect = createPostgresRuntimeDialect;