@m1212e/rumble 0.21.4 → 0.22.1

package/out/index.mjs

@@ -1,5 +1,5 @@
 import { t as lazy } from "./lazy-C7IyM4M4.mjs";
-import { t as generateFromSchema } from "./generate-B4w-hX0K.mjs";
+import { t as generateFromSchema } from "./generate-0QFVc3Sg.mjs";
 import { GraphQLError } from "graphql";
 import { EnvelopArmorPlugin } from "@escape.tech/graphql-armor";
 import { useDisableIntrospection } from "@graphql-yoga/plugin-disable-introspection";
@@ -180,7 +180,7 @@ function mapNullFieldsToUndefined(obj) {
 }
 //#endregion
 //#region package.json
-var version = "0.21.4";
+var version = "0.22.1";
 //#endregion
 //#region lib/helpers/mergeFilters.ts
 function mergeFilters(filterA, filterB, mode = "AND") {
@@ -815,66 +815,126 @@ function mapSQLTypeToGraphQLType({ sqlType, fieldName }) {
 const makeDefaultName = (dbName) => `${capitalize(toCamelCase(dbName.toString()))}WhereInputArgument`;
 const createWhereArgImplementer = ({ db, schemaBuilder, enumImplementer }) => {
 	const referenceStorage = /* @__PURE__ */ new Map();
+	const enumArrayWhereInputStorage = /* @__PURE__ */ new Map();
+	const getEnumArrayWhereInput = (enumImpl) => {
+		const typeName = `${enumImpl.name}WhereInputArgument`;
+		const existing = enumArrayWhereInputStorage.get(typeName);
+		if (existing) return existing;
+		const ret = schemaBuilder.inputRef(typeName);
+		enumArrayWhereInputStorage.set(typeName, ret);
+		ret.implement({ fields: (t) => ({
+			eq: t.field({
+				type: enumImpl,
+				required: false
+			}),
+			ne: t.field({
+				type: enumImpl,
+				required: false
+			}),
+			in: t.field({
+				type: [enumImpl],
+				required: false
+			}),
+			notIn: t.field({
+				type: [enumImpl],
+				required: false
+			}),
+			isNull: t.boolean({ required: false }),
+			isNotNull: t.boolean({ required: false }),
+			arrayOverlaps: t.field({
+				type: [enumImpl],
+				required: false
+			}),
+			arrayContained: t.field({
+				type: [enumImpl],
+				required: false
+			}),
+			arrayContains: t.field({
+				type: [enumImpl],
+				required: false
+			}),
+			AND: t.field({
+				type: [ret],
+				required: false
+			}),
+			OR: t.field({
+				type: [ret],
+				required: false
+			}),
+			NOT: t.field({
+				type: ret,
+				required: false
+			})
+		}) });
+		return ret;
+	};
 	const whereArgImplementer = ({ table, refName, dbName }) => {
 		const tableSchema = tableHelper({
 			db,
 			table: dbName ?? table
 		});
 		const inputTypeName = refName ?? makeDefaultName(tableSchema.tsName);
-		let ret = referenceStorage.get(inputTypeName);
-		if (ret) return ret;
-		const implement = () => {
-			return schemaBuilder.inputType(inputTypeName, { fields: (t) => {
-				const mapSQLTypeStringToInputPothosType = (sqlType, fieldName) => {
-					const gqlType = mapSQLTypeToGraphQLType({
-						sqlType,
-						fieldName
-					});
-					switch (gqlType) {
-						case "Int": return t.field({ type: "IntWhereInputArgument" });
-						case "String": return t.field({ type: "StringWhereInputArgument" });
-						case "Boolean": return t.boolean({ required: false });
-						case "Date": return t.field({ type: "DateWhereInputArgument" });
-						case "DateTime": return t.field({ type: "DateWhereInputArgument" });
-						case "Float": return t.field({ type: "FloatWhereInputArgument" });
-						case "ID": return t.id({ required: false });
-						case "JSON": return t.field({
-							type: "JSON",
-							required: false
-						});
-						default: throw new RumbleError(`Unsupported argument type ${gqlType} for column ${sqlType}`);
-					}
-				};
-				const fields = Object.entries(tableSchema.columns).reduce((acc, [key, value]) => {
-					if (isEnumSchema(value)) {
-						const enumImpl = enumImplementer({ enumColumn: value });
-						acc[key] = t.field({
-							type: enumImpl,
-							required: false
-						});
-					} else acc[key] = mapSQLTypeStringToInputPothosType(value.getSQLType(), key);
-					return acc;
-				}, {});
-				const relations = Object.entries(tableSchema.relations ?? {}).reduce((acc, [key, value]) => {
-					const targetTsName = value.targetTableName;
-					const referenceModel = whereArgImplementer({ dbName: tableHelper({
-						db,
-						table: targetTsName
-					}).dbName });
+		const existing = referenceStorage.get(inputTypeName);
+		if (existing) return existing;
+		const ret = schemaBuilder.inputRef(inputTypeName);
+		referenceStorage.set(inputTypeName, ret);
+		ret.implement({ fields: (t) => {
+			const mapSQLTypeStringToInputPothosType = (sqlType, fieldName) => {
+				const gqlType = mapSQLTypeToGraphQLType({
+					sqlType,
+					fieldName
+				});
+				switch (gqlType) {
+					case "Int": return t.field({ type: "IntWhereInputArgument" });
+					case "String": return t.field({ type: "StringWhereInputArgument" });
+					case "Boolean": return t.field({ type: "BooleanWhereInputArgument" });
+					case "Date": return t.field({ type: "DateWhereInputArgument" });
+					case "DateTime": return t.field({ type: "DateWhereInputArgument" });
+					case "Float": return t.field({ type: "FloatWhereInputArgument" });
+					case "ID": return t.field({ type: "IDWhereInputArgument" });
+					case "JSON": return t.field({ type: "JSONWhereInputArgument" });
+					default: throw new RumbleError(`Unsupported argument type ${gqlType} for column ${sqlType}`);
+				}
+			};
+			const fields = Object.entries(tableSchema.columns).reduce((acc, [key, value]) => {
+				if (isEnumSchema(value)) {
+					const enumImpl = enumImplementer({ enumColumn: value });
 					acc[key] = t.field({
-						type: referenceModel,
+						type: value.dimensions > 0 ? getEnumArrayWhereInput(enumImpl) : enumImpl,
 						required: false
 					});
-					return acc;
-				}, {});
-				return {
-					...fields,
-					...relations
-				};
-			} });
-		};
-		ret = implement();
-		referenceStorage.set(inputTypeName, ret);
+				} else acc[key] = mapSQLTypeStringToInputPothosType(value.getSQLType(), key);
+				return acc;
+			}, {});
+			const relations = Object.entries(tableSchema.relations ?? {}).reduce((acc, [key, value]) => {
+				const targetTsName = value.targetTableName;
+				const referenceModel = whereArgImplementer({ dbName: tableHelper({
+					db,
+					table: targetTsName
+				}).dbName });
+				acc[key] = t.field({
+					type: referenceModel,
+					required: false
+				});
+				return acc;
+			}, {});
+			return {
+				...fields,
+				...relations,
+				AND: t.field({
+					type: [ret],
+					required: false
+				}),
+				OR: t.field({
+					type: [ret],
+					required: false
+				}),
+				NOT: t.field({
+					type: ret,
+					required: false
+				})
+			};
+		} });
 		return ret;
 	};
 	return whereArgImplementer;
@@ -921,7 +981,7 @@ function deepSetProto(obj, proto = Object.prototype, seen = /* @__PURE__ */ new
 	if (obj === null || typeof obj !== "object") return;
 	if (seen.has(obj)) return;
 	seen.add(obj);
-	Object.setPrototypeOf(obj, proto);
+	if (!Array.isArray(obj)) Object.setPrototypeOf(obj, proto);
 	for (const key of Object.keys(obj)) deepSetProto(obj[key], proto, seen);
 }
 //#endregion
@@ -1121,7 +1181,11 @@ async function initSearchIfApplicable(input) {
 		const threshold = Number(input.search.threshold);
 		if (threshold < 0 || threshold > 1) throw new Error(`Search threshold must be between 0 and 1`);
 		const dbName = (await input.db.execute(sql`SELECT current_database()`)).rows[0].current_database;
-		await input.db.execute(sql.raw(`ALTER DATABASE ${dbName} SET pg_trgm.similarity_threshold = ${threshold};`));
+		try {
+			await input.db.execute(sql.raw(`ALTER DATABASE ${dbName} SET pg_trgm.similarity_threshold = ${threshold};`));
+		} catch (error) {
+			if (error?.cause?.code !== "XX000" && error?.code !== "XX000") throw error;
+		}
 	}
 	if (input.search?.cpu_operator_cost) {
 		if (typeof input.search.cpu_operator_cost !== "number") throw new Error(`CPU operator cost must be a number`);
@@ -1588,6 +1652,77 @@ function implementDefaultWhereInputArgs(schemaBuilder) {
 		OR: t.field({ type: [DateWhereInputArgument] }),
 		NOT: t.field({ type: DateWhereInputArgument })
 	}) });
+	const BooleanWhereInputArgument = schemaBuilder.inputRef("BooleanWhereInputArgument").implement({ fields: (t) => ({
+		eq: t.boolean(),
+		ne: t.boolean(),
+		in: t.booleanList(),
+		notIn: t.booleanList(),
+		isNull: t.boolean(),
+		isNotNull: t.boolean(),
+		arrayOverlaps: t.booleanList(),
+		arrayContained: t.booleanList(),
+		arrayContains: t.booleanList(),
+		AND: t.field({ type: [BooleanWhereInputArgument] }),
+		OR: t.field({ type: [BooleanWhereInputArgument] }),
+		NOT: t.field({ type: BooleanWhereInputArgument })
+	}) });
+	const IDWhereInputArgument = schemaBuilder.inputRef("IDWhereInputArgument").implement({ fields: (t) => ({
+		eq: t.id(),
+		ne: t.id(),
+		gt: t.id(),
+		gte: t.id(),
+		lt: t.id(),
+		lte: t.id(),
+		in: t.idList(),
+		notIn: t.idList(),
+		like: t.string(),
+		ilike: t.string(),
+		notLike: t.string(),
+		notIlike: t.string(),
+		isNull: t.boolean(),
+		isNotNull: t.boolean(),
+		arrayOverlaps: t.idList(),
+		arrayContained: t.idList(),
+		arrayContains: t.idList(),
+		AND: t.field({ type: [IDWhereInputArgument] }),
+		OR: t.field({ type: [IDWhereInputArgument] }),
+		NOT: t.field({ type: IDWhereInputArgument })
+	}) });
+	const JSONWhereInputArgument = schemaBuilder.inputRef("JSONWhereInputArgument").implement({ fields: (t) => ({
+		eq: t.field({
+			type: "JSON",
+			required: false
+		}),
+		ne: t.field({
+			type: "JSON",
+			required: false
+		}),
+		in: t.field({
+			type: ["JSON"],
+			required: false
+		}),
+		notIn: t.field({
+			type: ["JSON"],
+			required: false
+		}),
+		isNull: t.boolean(),
+		isNotNull: t.boolean(),
+		arrayOverlaps: t.field({
+			type: ["JSON"],
+			required: false
+		}),
+		arrayContained: t.field({
+			type: ["JSON"],
+			required: false
+		}),
+		arrayContains: t.field({
+			type: ["JSON"],
+			required: false
+		}),
+		AND: t.field({ type: [JSONWhereInputArgument] }),
+		OR: t.field({ type: [JSONWhereInputArgument] }),
+		NOT: t.field({ type: JSONWhereInputArgument })
+	}) });
 }
 //#endregion
 //#region lib/runtimeFiltersPlugin/filterTypes.ts