@m1212e/rumble 0.18.9 → 0.21.2

package/out/index.mjs

@@ -1,5 +1,5 @@
-import { t as lazy } from "./lazy-BgeBy3-B.mjs";
-import { t as generateFromSchema } from "./generate-BxAyU8HE.mjs";
+import { t as lazy } from "./lazy-C7IyM4M4.mjs";
+import { t as generateFromSchema } from "./generate-B4w-hX0K.mjs";
 import { GraphQLError } from "graphql";
 import { EnvelopArmorPlugin } from "@escape.tech/graphql-armor";
 import { useDisableIntrospection } from "@graphql-yoga/plugin-disable-introspection";
@@ -7,9 +7,9 @@ import { SpanStatusCode, trace } from "@opentelemetry/api";
 import { AttributeNames, SpanNames, createOpenTelemetryWrapper } from "@pothos/tracing-opentelemetry";
 import { capitalize, cloneDeep, debounce, merge, toMerged } from "es-toolkit";
 import { createPubSub, createYoga } from "graphql-yoga";
-import { One, count, relationsFilterToSQL, sql } from "drizzle-orm";
-import { CasingCache, toCamelCase } from "drizzle-orm/casing";
-import { PgEnumColumn, PgTable } from "drizzle-orm/pg-core";
+import { One, count, getTableColumns, getTableName, is, isTable, relationsFilterToSQL, sql } from "drizzle-orm";
+import { toCamelCase } from "drizzle-orm/casing";
+import { PgColumn, PgEnumColumn, PgEnumObjectColumn, PgTable, isPgEnum } from "drizzle-orm/pg-core";
 import pluralize from "pluralize";
 import { MySqlTable } from "drizzle-orm/mysql-core";
 import { SQLiteTable } from "drizzle-orm/sqlite-core";
@@ -180,7 +180,7 @@ function mapNullFieldsToUndefined(obj) {
 }
 //#endregion
 //#region package.json
-var version = "0.18.9";
+var version = "0.21.2";
 //#endregion
 //#region lib/helpers/mergeFilters.ts
 function mergeFilters(filterA, filterB, mode = "AND") {
@@ -300,26 +300,70 @@ function createDistinctValuesFromSQLType(sqlType) {
 }
 //#endregion
 //#region lib/helpers/tableHelpers.ts
-const drizzleNameSymbol = Symbol.for("drizzle:Name");
-const drizzleOriginalNameSymbol = Symbol.for("drizzle:OriginalName");
-const drizzleBaseNameSymbol = Symbol.for("drizzle:BaseName");
+const indexCache = /* @__PURE__ */ new WeakMap();
+function buildIndex(db) {
+	const byTsName = /* @__PURE__ */ new Map();
+	const byDbName = /* @__PURE__ */ new Map();
+	const byTableRef = /* @__PURE__ */ new Map();
+	for (const [tsName, rawEntry] of Object.entries(db._.relations ?? {})) {
+		const entry = rawEntry;
+		const tableObj = entry.table;
+		if (!tableObj) continue;
+		const columns = isTable(tableObj) ? getTableColumns(tableObj) : {};
+		const primaryKey = Object.fromEntries(Object.entries(columns).filter(([, col]) => col.primary));
+		const dbName = isTable(tableObj) ? getTableName(tableObj) : entry.name ?? tsName;
+		const resolved = {
+			name: entry.name ?? tsName,
+			dbName,
+			table: tableObj,
+			columns,
+			primaryKey,
+			relations: entry.relations ?? {},
+			foundRelation: entry
+		};
+		byTsName.set(resolved.name, resolved);
+		byDbName.set(resolved.dbName, resolved);
+		byTableRef.set(tableObj, resolved);
+	}
+	return {
+		byTsName,
+		byDbName,
+		byTableRef
+	};
+}
+function getIndex(db) {
+	let idx = indexCache.get(db);
+	if (!idx) {
+		idx = buildIndex(db);
+		indexCache.set(db, idx);
+	}
+	return idx;
+}
 function tableHelper({ db, table }) {
-	if (typeof table !== "string") table = table.tsName || table.dbName || table[drizzleNameSymbol] || table[drizzleOriginalNameSymbol] || table[drizzleBaseNameSymbol];
-	const foundRelation = Object.values(db._.relations).find((schema) => schema.name === table || schema.table[drizzleNameSymbol] === table || schema.table[drizzleOriginalNameSymbol] === table || schema.table[drizzleBaseNameSymbol] === table);
-	if (!foundRelation) throw new RumbleError(`Could not find schema for ${JSON.stringify(table)}`);
-	const foundSchema = Object.values(db._.schema).find((schema) => schema.dbName === foundRelation.table[drizzleOriginalNameSymbol]);
-	if (!foundSchema) throw new RumbleError(`Could not find schema for ${JSON.stringify(table)}`);
-	const fullSchema = db._.fullSchema?.[foundSchema.tsName];
-	if (!fullSchema) throw new RumbleError(`Could not find full schema for ${JSON.stringify(table)}`);
+	const idx = getIndex(db);
+	let entry;
+	if (typeof table === "string") entry = idx.byTsName.get(table) ?? idx.byDbName.get(table);
+	else if (table && typeof table === "object") {
+		const t = table;
+		if (t.table) {
+			entry = idx.byTableRef.get(t.table);
+			if (!entry && t.name) entry = idx.byTsName.get(t.name) ?? idx.byDbName.get(t.name);
+		}
+		if (!entry) entry = idx.byTableRef.get(t);
+		if (!entry && isTable(t)) {
+			const dbName = getTableName(t);
+			entry = idx.byDbName.get(dbName);
+		}
+	}
+	if (!entry) throw new RumbleError(`Could not find schema for ${JSON.stringify(typeof table === "string" ? table : "<table-object>")}`);
 	return {
-		columns: foundSchema.columns,
-		primaryKey: foundSchema.primaryKey,
-		relations: foundRelation.relations,
-		dbName: foundSchema.dbName,
-		tsName: foundSchema.tsName,
-		foundSchema,
-		foundRelation,
-		fullSchema
+		columns: entry.columns,
+		primaryKey: entry.primaryKey,
+		relations: entry.relations,
+		dbName: entry.dbName,
+		tsName: entry.name,
+		table: entry.table,
+		foundRelation: entry.foundRelation
 	};
 }
 //#endregion
@@ -472,7 +516,7 @@ by: (explicitFilter) => {
 								return limit ?? void 0;
 							});
 							const sqlTransformedWhere = lazy(() => {
-								const casing = db._.session?.dialect?.casing ?? new CasingCache();
+								const casing = db._.session?.dialect?.casing;
 								return filters?.where ? relationsFilterToSQL(tableSchema.foundRelation.table, filters.where, tableSchema.relations, db._.relations, casing) : void 0;
 							});
 							if (filters?.columns) return {
@@ -673,9 +717,10 @@ const createOrderArgImplementer = ({ db, schemaBuilder }) => {
 					return acc;
 				}, {});
 				const relations = Object.entries(tableSchema.relations ?? {}).reduce((acc, [key, value]) => {
+					const targetTsName = value.targetTableName;
 					const referenceModel = orderArgImplementer({ dbName: tableHelper({
 						db,
-						table: value.targetTable
+						table: targetTsName
 					}).dbName });
 					acc[key] = t.field({
 						type: referenceModel,
@@ -698,27 +743,45 @@ const createOrderArgImplementer = ({ db, schemaBuilder }) => {
 //#endregion
 //#region lib/enum.ts
 /**
-* Checks if a schema type is an enum
+* Checks if a column is a Postgres enum column
 */
 function isEnumSchema(schemaType) {
-	return schemaType instanceof PgEnumColumn;
+	return is(schemaType, PgEnumColumn) || is(schemaType, PgEnumObjectColumn);
 }
-const createEnumImplementer = ({ db, schemaBuilder }) => {
+const createEnumImplementer = ({ schema, schemaBuilder }) => {
 	const referenceStorage = /* @__PURE__ */ new Map();
-	const enumImplementer = ({ tsName, enumColumn, refName }) => {
+	/**
+	* Registers a Postgres enum as a GraphQL enum type.
+	*
+	* You can identify the enum in three ways:
+	* - `tsName`: the exported TypeScript identifier from your schema module. This is the
+	*   most typesafe form, only valid enum keys autocomplete, typos are caught at compile time.
+	* - `enum`: pass the pgEnum object directly.
+	* - `enumColumn`: pass a column that uses the enum.
+	*
+	* Use `refName` to override the auto-generated GraphQL type name.
+	*/
+	const enumImplementer = (args) => {
+		const { refName } = args;
+		const tsName = args.tsName;
+		const enumObjectArg = args.enum;
+		const enumColumn = args.enumColumn;
+		let enumObject = enumObjectArg;
+		if (tsName) {
+			const candidate = schema[tsName];
+			if (!candidate || !isPgEnum(candidate)) throw new RumbleError(`Could not find a pgEnum exported as ${JSON.stringify(tsName)} in the provided schema. Make sure the identifier exists and refers to a value created with \`pgEnum(...)\`.`);
+			enumObject = candidate;
+		}
+		if (!enumObject && !enumColumn) throw new RumbleError("Could not determine enum structure! Pass one of 'tsName' (requires `schema` on rumble()), 'enum' (the pgEnum object), or 'enumColumn' (a column that uses the enum).");
 		let enumSchemaName;
 		let enumValues;
-		if (tsName) {
-			const schemaEnum = db._.fullSchema[tsName];
-			enumSchemaName = tsName.toString();
-			const enumCol = Object.values(db._.schema).filter((s) => typeof s === "object").map((s) => Object.values(s.columns)).flat(2).filter(isEnumSchema).find((e) => e.config.enum === schemaEnum);
-			if (!enumCol) throw new RumbleError(`Could not find applied enum column for ${tsName.toString()}.
-Please ensure that you use the enum at least once as a column of a table!`);
-			enumValues = enumCol.enumValues;
+		if (enumObject) {
+			enumSchemaName = enumObject.enumName;
+			enumValues = enumObject.enumValues;
 		} else if (enumColumn) {
-			const entry = Object.entries(db._.fullSchema).filter(([_, value]) => enumColumn.config.enum === value)[0];
-			if (!entry) throw new RumbleError(`Could not find enum entry for ${enumColumn.config.name}.`);
-			enumSchemaName = entry[0];
+			const pgEnum = enumColumn.enum;
+			if (!pgEnum) throw new RumbleError(`Could not find enum definition on column. Make sure the column is a pgEnum column.`);
+			enumSchemaName = pgEnum.enumName;
 			enumValues = enumColumn.enumValues;
 		}
 		if (!enumSchemaName || !enumValues) throw new RumbleError("Could not determine enum structure!");
@@ -794,9 +857,10 @@ const createWhereArgImplementer = ({ db, schemaBuilder, enumImplementer }) => {
 					return acc;
 				}, {});
 				const relations = Object.entries(tableSchema.relations ?? {}).reduce((acc, [key, value]) => {
+					const targetTsName = value.targetTableName;
 					const referenceModel = whereArgImplementer({ dbName: tableHelper({
 						db,
-						table: value.targetTable
+						table: targetTsName
 					}).dbName });
 					acc[key] = t.field({
 						type: referenceModel,
@@ -891,10 +955,10 @@ const createCountQueryImplementer = ({ db, schemaBuilder, whereArgImplementer, m
 					type: WhereArg,
 					required: false
 				}) },
-				resolve: async (root, args, ctx, info) => {
+				resolve: async (_root, args, ctx, _info) => {
 					if (isAllowed && !await isAllowed(ctx)) throw new RumbleErrorSafe("Not allowed to perform this action");
 					deepSetProto(args);
-					return db.select({ count: count() }).from(tableSchema.fullSchema).where(ctx.abilities[table].filter(listAction).merge(mapNullFieldsToUndefined(args)).sql.where).then(assertFirstEntryExists).then((r) => r.count);
+					return db.select({ count: count() }).from(tableSchema.table).where(ctx.abilities[table].filter(listAction).merge(mapNullFieldsToUndefined(args)).sql.where).then(assertFirstEntryExists).then((r) => r.count);
 				}
 			}) };
 		});
@@ -1018,16 +1082,23 @@ function buildPothosResponseTypeFromGraphQLType({ builder, sqlType, fieldName, n
 }
 //#endregion
 //#region lib/helpers/determineDialectFromSchema.ts
+const dialectCache = /* @__PURE__ */ new WeakMap();
 function determineDBDialectFromSchema(schema) {
+	const cached = dialectCache.get(schema);
+	if (cached) return cached;
 	const found = /* @__PURE__ */ new Set();
 	for (const table of Object.values(schema).map((t) => t.table)) {
-		if (typeof table !== "object") continue;
-		if (table instanceof PgTable) found.add("postgres");
-		else if (table instanceof MySqlTable) found.add("mysql");
-		else if (table instanceof SQLiteTable) found.add("sqlite");
+		if (!table || typeof table !== "object") continue;
+		if (is(table, PgTable)) found.add("postgres");
+		else if (is(table, MySqlTable)) found.add("mysql");
+		else if (is(table, SQLiteTable)) found.add("sqlite");
 	}
 	const dialects = Array.from(found);
-	if (dialects.length === 1) return dialects[0];
+	if (dialects.length === 1) {
+		const only = dialects[0];
+		dialectCache.set(schema, only);
+		return only;
+	}
 	if (dialects.length === 0) throw new Error("No tables found in schema, could not determine dialect");
 	throw new Error(`Multiple dialects found in schema: ${dialects.join(", ")}`);
 }
@@ -1059,7 +1130,7 @@ async function initSearchIfApplicable(input) {
 */
 function adjustQueryArgsForSearch({ search, args, tableSchema, abilities }) {
 	if (search?.enabled && args.search && args.search.length > 0) {
-		const columnsToSearch = (abilities.query.many.columns ? Object.entries(tableSchema.columns).filter(([key]) => abilities.query.many.columns[key]) : Object.entries(tableSchema.columns)).filter(([key, col]) => isStringLikeSQLTypeString(col.getSQLType()) || isIDLikeSQLTypeString(col.getSQLType()));
+		const columnsToSearch = (abilities.query.many.columns ? Object.entries(tableSchema.columns).filter(([key]) => abilities.query.many.columns[key]) : Object.entries(tableSchema.columns)).filter(([_key, col]) => isStringLikeSQLTypeString(col.getSQLType()) || isIDLikeSQLTypeString(col.getSQLType()));
 		const searchParam = sql`${args.search}`;
 		args.extras = { search_distance: (table) => sql`${sql.join(columnsToSearch.map(([key]) => {
 			return sql`COALESCE((${table[key]}::TEXT <-> ${searchParam}), 1)`;
@@ -1125,7 +1196,7 @@ const createObjectImplementer = ({ db, search, schemaBuilder, makePubSubInstance
 			fields: (t) => {
 				const columns = tableSchema.columns;
 				const configMap = /* @__PURE__ */ new Map();
-				const userAdjustments = adjust?.(new Proxy(t, { get: (target, prop, receiver) => {
+				const userAdjustments = adjust?.(new Proxy(t, { get: (target, prop, _receiver) => {
 					if (typeof target[prop] !== "function" || prop === "arg" || prop === "builder" || prop === "graphqlKind" || prop === "kind" || prop === "listRef" || prop === "table" || prop === "typename" || prop === "variant" || prop.toString().startsWith("boolean") || prop.toString().startsWith("float") || prop.toString().startsWith("id") || prop.toString().startsWith("int") || prop.toString().startsWith("string") || prop.toString().startsWith("expose")) return target[prop];
 					return (...params) => {
 						const ref = target[prop](...params);
@@ -1147,9 +1218,12 @@ const createObjectImplementer = ({ db, search, schemaBuilder, makePubSubInstance
 						return acc;
 					}
 					let isArray = false;
-					if (column.dimensions > 0) {
-						if (column.dimensions !== 1) throw new RumbleError("Only one-dimensional arrays are supported for default object implementation");
-						isArray = true;
+					if (is(column, PgColumn)) {
+						const dimensions = column.dimensions;
+						if (dimensions && dimensions > 0) {
+							if (dimensions !== 1) throw new RumbleError("Only one-dimensional arrays are supported for default object implementation");
+							isArray = true;
+						}
 					}
 					if (isEnumSchema(column)) {
 						const enumImpl = enumImplementer({ enumColumn: column });
@@ -1168,9 +1242,10 @@ const createObjectImplementer = ({ db, search, schemaBuilder, makePubSubInstance
 					return acc;
 				}, {});
 				const relations = Object.entries(tableSchema.relations ?? {}).reduce((acc, [key, value]) => {
+					const targetTsName = value.targetTableName;
 					const relationSchema = tableHelper({
 						db,
-						table: value.targetTable
+						table: targetTsName
 					});
 					const WhereArg = whereArgImplementer({ dbName: relationSchema.dbName });
 					const OrderArg = orderArgImplementer({ dbName: relationSchema.dbName });
@@ -1178,7 +1253,7 @@ const createObjectImplementer = ({ db, search, schemaBuilder, makePubSubInstance
 					let nullable = false;
 					let isMany = true;
 					let filterSpecifier = "many";
-					if (value instanceof One) {
+					if (is(value, One)) {
 						isMany = false;
 						nullable = value.optional || !value.sourceColumns.every((column) => column.notNull);
 						filterSpecifier = "single";
@@ -1246,7 +1321,7 @@ const createObjectImplementer = ({ db, search, schemaBuilder, makePubSubInstance
 					fields.search_distance = t.float({
 						description: "The search distance of the object. If a search is provided, this field will be populated with the search distance.",
 						nullable: true,
-						resolve: (parent, args, ctx, info) => parent.search_distance
+						resolve: (parent, _args, _ctx, _info) => parent.search_distance
 					});
 				}
 				return {
@@ -1611,9 +1686,10 @@ const createSchemaBuilder = ({ db, disableDefaultObjects, pubsub, pothosConfig,
 			client: db,
 			relations: db._.relations,
 			getTableConfig(table) {
+				const columns = isTable(table) ? Object.values(getTableColumns(table)) : [];
 				return {
-					columns: Object.values(table[Symbol.for("drizzle:Columns")]),
-					primaryKeys: Object.values(table[Symbol.for("drizzle:Columns")]).filter((v) => v.primary)
+					columns,
+					primaryKeys: columns.filter((v) => v.primary)
 				};
 			}
 		},
@@ -1639,19 +1715,6 @@ const createSchemaBuilder = ({ db, disableDefaultObjects, pubsub, pothosConfig,
 //#endregion
 //#region lib/rumble.ts
 const rumble = (rumbleInput) => {
-	if (!rumbleInput.db._.schema) throw new RumbleError(`
-rumble could not find any schema in the provided drizzle instance.
-Make sure you import the schema and pass it to the drizzle instance:
-
-export const db = drizzle(
-  "postgres://postgres:postgres@localhost:5432/postgres",
-  {
-    relations,
-    schema,    // <--- add this line
-  },
-);
-
-`);
 	if (!rumbleInput.db._.relations) throw new RumbleError(`
 rumble could not find any relations in the provided drizzle instance.
 Make sure you import the relations and pass them to the drizzle instance:
@@ -1660,10 +1723,21 @@ export const db = drizzle(
   "postgres://postgres:postgres@localhost:5432/postgres",
   {
     relations, // <--- add this line
-    schema,
   },
 );
 
+`);
+	if (!rumbleInput.schema || typeof rumbleInput.schema !== "object" || Object.keys(rumbleInput.schema).length === 0) throw new RumbleError(`
+rumble requires the drizzle schema object to be passed when initializing.
+Import your schema module and pass it alongside \`db\`:
+
+import * as schema from "./db/schema";
+
+export const r = rumble({
+  db,
+  schema, // <--- add this line
+});
+
 `);
 	if (!rumbleInput.actions) rumbleInput.actions = [
 		"read",