@m1212e/rumble 0.15.4 → 0.16.3

package/out/index.cjs

@@ -21,15 +21,11 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
-let node_fs_promises = require("node:fs/promises");
-let node_path = require("node:path");
-let __urql_introspection = require("@urql/introspection");
-let devalue = require("devalue");
+const require_generate = require('./generate-HCpRd3Cx.cjs');
 let graphql = require("graphql");
-let es_toolkit = require("es-toolkit");
-let wonka = require("wonka");
 let __escape_tech_graphql_armor = require("@escape.tech/graphql-armor");
 let __graphql_yoga_plugin_disable_introspection = require("@graphql-yoga/plugin-disable-introspection");
+let es_toolkit = require("es-toolkit");
 let graphql_yoga = require("graphql-yoga");
 let sofa_api = require("sofa-api");
 let drizzle_orm = require("drizzle-orm");
@@ -47,425 +43,6 @@ let __pothos_plugin_smart_subscriptions = require("@pothos/plugin-smart-subscrip
 __pothos_plugin_smart_subscriptions = __toESM(__pothos_plugin_smart_subscriptions);
 let graphql_scalars = require("graphql-scalars");
 
-//#region lib/client/generate/client.ts
-function generateClient({ apiUrl, rumbleImportPath, useExternalUrqlClient, availableSubscriptions, schemaPath, forceReactivity }) {
-	const imports = [];
-	let code = "";
-	if (typeof useExternalUrqlClient === "string") imports.push(`import { urqlClient } from "${useExternalUrqlClient}";`);
-	imports.push(`import { Client, fetchExchange } from '@urql/core';`);
-	imports.push(`import { cacheExchange } from '@urql/exchange-graphcache';`);
-	imports.push(`import { nativeDateExchange } from '${rumbleImportPath}';`);
-	imports.push(`import { schema } from '${schemaPath}';`);
-	imports.push(`import { makeLiveQuery, makeMutation, makeSubscription, makeQuery } from '${rumbleImportPath}';`);
-	const forceReactivityValueString = typeof forceReactivity === "boolean" && forceReactivity ? "true" : "";
-	const forceReactivityFieldString = forceReactivityValueString !== "" ? `forceReactivity: ${forceReactivityValueString}` : "";
-	code += `
-export const defaultOptions: ConstructorParameters<Client>[0] = {
-  url: "${apiUrl ?? "PLEASE PROVIDE A URL WHEN GENERATING OR IMPORT AN EXTERNAL URQL CLIENT"}",
-  fetchSubscriptions: true,
-  exchanges: [cacheExchange({ schema }), nativeDateExchange, fetchExchange],
-  fetchOptions: {
-    credentials: "include",
-  },
-  requestPolicy: "cache-and-network",
-}
-`;
-	if (!useExternalUrqlClient) code += `
-const urqlClient = new Client(defaultOptions);
-`;
-	code += `
-export const client = {
-  /**
-   * A query and subscription combination. First queries and if exists, also subscribes to a subscription of the same name.
-   * Combines the results of both, so the result is first the query result and then live updates from the subscription.
-   * Assumes that the query and subscription return the same fields as per default when using the rumble query helpers.
-   * If no subscription with the same name exists, this will just be a query.
-   */
-  liveQuery: makeLiveQuery<Query${`, ${forceReactivityValueString}`}>({
-	  urqlClient,
-	  availableSubscriptions: new Set([${availableSubscriptions.values().toArray().map((value) => `"${value}"`).join(", ")}]),
-		${forceReactivityFieldString}
-  }),
-  /**
-   * A mutation that can be used to e.g. create, update or delete data.
-   */
-  mutate: makeMutation<Mutation${`, ${forceReactivityValueString}`}>({
-	  urqlClient,
-		${forceReactivityFieldString}
-  }),
-  /**
-   * A continuous stream of results that updates when the server sends new data.
-   */
-  subscribe: makeSubscription<Subscription${`, ${forceReactivityValueString}`}>({
-	  urqlClient,
-		${forceReactivityFieldString}
-  }),
-  /**
-   * A one-time fetch of data.
-   */
-  query: makeQuery<Query${`, ${forceReactivityValueString}`}>({
-	  urqlClient,
-		${forceReactivityValueString !== "" ? `forceReactivity: ${forceReactivityValueString}` : ""}
-  }),
-}`;
-	return {
-		imports,
-		code
-	};
-}
-
-//#endregion
-//#region lib/client/generate/tsRepresentation.ts
-function makeTSRepresentation(model) {
-	if (model instanceof graphql.GraphQLObjectType) return makeTSTypeFromObject(model);
-	else if (model instanceof graphql.GraphQLScalarType) return mapGraphqlScalarToTSTypeString(model);
-	else if (model instanceof graphql.GraphQLEnumType) return makeStringLiteralUnionFromEnum(model);
-	else if (model instanceof graphql.GraphQLInputObjectType) return makeTSTypeFromInputObject(model);
-	throw new Error(`Unknown model type: ${model}`);
-}
-function makeTSTypeFromObject(model) {
-	const stringifiedFields = /* @__PURE__ */ new Map();
-	for (const [key, value] of Object.entries(model.getFields())) stringifiedFields.set(key, makeTSObjectTypeField(value.type, value.args));
-	return `{
-  ${stringifiedFields.entries().map(([key, value]) => `${key}: ${value}`).toArray().join(",\n  ")}    
-}`;
-}
-function makeTSTypeFromInputObject(model) {
-	const stringifiedFields = /* @__PURE__ */ new Map();
-	for (const [key, value] of Object.entries(model.getFields())) stringifiedFields.set(key, makeTSInputObjectTypeField(value.type));
-	return `{
-  ${stringifiedFields.entries().map(([key, value]) => `${key}${value.includes("| undefined") ? "?" : ""}: ${value}`).toArray().join(",\n  ")}    
-}`;
-}
-function makeTSObjectTypeField(returnType, args) {
-	let isNonNullReturnType = false;
-	let isList = false;
-	for (let index = 0; index < 3; index++) {
-		if (returnType instanceof graphql.GraphQLList) {
-			isList = true;
-			returnType = returnType.ofType;
-		}
-		if (returnType instanceof graphql.GraphQLNonNull) {
-			isNonNullReturnType = true;
-			returnType = returnType.ofType;
-		}
-	}
-	let returnTypeString = returnType.name;
-	if (isList) returnTypeString += "[]";
-	if (!isNonNullReturnType) returnTypeString += " | null";
-	const isRelationType = returnType instanceof graphql.GraphQLObjectType;
-	const argsStringMap = /* @__PURE__ */ new Map();
-	for (const arg of args ?? []) argsStringMap.set(arg.name, stringifyTSObjectArg(arg.type));
-	if (isRelationType) {
-		const makePOptional = argsStringMap.entries().every(([, value]) => value.includes("| undefined"));
-		return `(${(args ?? []).length > 0 ? `p${makePOptional ? "?" : ""}: {
-  ${argsStringMap.entries().map(([key, value]) => `  ${key}${value.includes("| undefined") ? "?" : ""}: ${value}`).toArray().join(",\n  ")}
-  }` : ""}) => ${returnTypeString}`;
-	} else return returnTypeString;
-}
-function makeTSInputObjectTypeField(returnType) {
-	let isNonNullReturnType = false;
-	let isList = false;
-	for (let index = 0; index < 3; index++) {
-		if (returnType instanceof graphql.GraphQLList) {
-			isList = true;
-			returnType = returnType.ofType;
-		}
-		if (returnType instanceof graphql.GraphQLNonNull) {
-			isNonNullReturnType = true;
-			returnType = returnType.ofType;
-		}
-	}
-	let returnTypeString = returnType.name;
-	if (isList) returnTypeString += "[]";
-	if (!isNonNullReturnType) returnTypeString += " | null | undefined";
-	else if (isList) returnTypeString += " | undefined";
-	return returnTypeString;
-}
-function stringifyTSObjectArg(arg) {
-	let ret = "unknown";
-	let isNullable = true;
-	if (arg instanceof graphql.GraphQLNonNull) {
-		isNullable = false;
-		arg = arg.ofType;
-	}
-	if (arg instanceof graphql.GraphQLInputObjectType || arg instanceof graphql.GraphQLScalarType) ret = arg.name;
-	if (isNullable) ret += " | null | undefined";
-	return ret;
-}
-function mapGraphqlScalarToTSTypeString(arg) {
-	switch (arg.name) {
-		case "ID": return "string";
-		case "String": return "string";
-		case "Boolean": return "boolean";
-		case "Int": return "number";
-		case "Float": return "number";
-		case "Date": return "Date";
-		case "DateTime": return "Date";
-		case "JSON": return "any";
-		default: return "unknown";
-	}
-}
-function makeStringLiteralUnionFromEnum(enumType) {
-	return enumType.getValues().map((value) => `"${value.name}"`).join(" | ");
-}
-
-//#endregion
-//#region lib/client/generate/generate.ts
-async function generateFromSchema({ outputPath, schema, rumbleImportPath = "@m1212e/rumble", apiUrl, useExternalUrqlClient = false, removeExisting = true, forceReactivity }) {
-	if (removeExisting) try {
-		await (0, node_fs_promises.access)(outputPath);
-		await (0, node_fs_promises.rm)(outputPath, {
-			recursive: true,
-			force: true
-		});
-	} catch (_error) {}
-	await (0, node_fs_promises.mkdir)(outputPath, { recursive: true });
-	if (!outputPath.endsWith("/")) outputPath += "/";
-	const imports = [];
-	let code = "";
-	const typeMap = /* @__PURE__ */ new Map();
-	for (const [key, object] of Object.entries(schema.getTypeMap())) {
-		if (key.startsWith("__")) continue;
-		typeMap.set(key, object);
-	}
-	for (const [key, object] of typeMap.entries()) {
-		const rep = makeTSRepresentation(object);
-		if (rep === key) continue;
-		code += `
-export type ${key} = ${rep};
-		`;
-	}
-	const schemaFileName = "schema";
-	const c = generateClient({
-		apiUrl,
-		schemaPath: `./${schemaFileName}`,
-		useExternalUrqlClient,
-		rumbleImportPath,
-		availableSubscriptions: new Set(Object.keys(schema.getSubscriptionType()?.getFields() || {})),
-		forceReactivity
-	});
-	imports.push(...c.imports);
-	code += c.code;
-	await Promise.all([(0, node_fs_promises.writeFile)((0, node_path.join)(outputPath, "client.ts"), `${imports.join("\n")}\n${code}`), (0, node_fs_promises.writeFile)((0, node_path.join)(outputPath, `${schemaFileName}.ts`), `// @ts-ignore
-export const schema = ${(0, devalue.uneval)((0, __urql_introspection.minifyIntrospectionQuery)((0, __urql_introspection.getIntrospectedSchema)(schema)))}`)]);
-}
-
-//#endregion
-//#region lib/client/request.ts
-const argsKey = "__args";
-function makeGraphQLQueryRequest({ queryName, input, client, enableSubscription = false, forceReactivity }) {
-	const otwQueryName = `${(0, es_toolkit.capitalize)(queryName)}Query`;
-	const argsString = stringifyArgumentObjectToGraphqlList(input?.[argsKey] ?? {});
-	const operationString = (operationVerb) => `${operationVerb} ${otwQueryName} { ${queryName}${argsString} ${input ? `{ ${stringifySelection(input)} }` : ""}}`;
-	const awaitedReturnValueReference = {};
-	const source = (0, wonka.pipe)((0, wonka.merge)([client.query(operationString("query"), {}), enableSubscription ? client.subscription(operationString("subscription"), {}) : wonka.empty]), wonka.share, (0, wonka.map)((v) => {
-		const data = v.data?.[queryName];
-		if (!data && v.error) throw v.error;
-		return data;
-	}), (0, wonka.onPush)((data) => {
-		if (typeof data === "object" && data !== null && typeof forceReactivity === "boolean" && forceReactivity) Object.assign(awaitedReturnValueReference, data);
-	}));
-	const observable = (0, wonka.toObservable)(source);
-	const promise = (0, wonka.toPromise)((0, wonka.pipe)(source, (0, wonka.take)(1), (0, wonka.map)((data) => {
-		Object.assign(awaitedReturnValueReference, observable);
-		if (typeof data === "object" && data !== null && typeof forceReactivity === "boolean" && forceReactivity) {
-			Object.assign(awaitedReturnValueReference, data);
-			return awaitedReturnValueReference;
-		}
-		return data;
-	})));
-	Object.assign(promise, observable);
-	return promise;
-}
-function makeGraphQLMutationRequest({ mutationName, input, client, forceReactivity }) {
-	const operationString = `mutation ${`${(0, es_toolkit.capitalize)(mutationName)}Mutation`} { ${mutationName}${stringifyArgumentObjectToGraphqlList(input[argsKey] ?? {})} { ${stringifySelection(input)} }}`;
-	const response = (0, wonka.pipe)(client.mutation(operationString, {}), (0, wonka.map)((v) => {
-		const data = v.data?.[mutationName];
-		if (!data && v.error) throw v.error;
-		return data;
-	}));
-	const observable = (0, wonka.toObservable)(response);
-	const promise = (0, wonka.toPromise)((0, wonka.pipe)(response, (0, wonka.take)(1)));
-	Object.assign(promise, observable);
-	return promise;
-}
-function makeGraphQLSubscriptionRequest({ subscriptionName, input, client, forceReactivity }) {
-	const operationString = `subscription ${`${(0, es_toolkit.capitalize)(subscriptionName)}Subscription`} { ${subscriptionName}${stringifyArgumentObjectToGraphqlList(input[argsKey] ?? {})} { ${stringifySelection(input)} }}`;
-	return (0, wonka.pipe)(client.subscription(operationString, {}), (0, wonka.map)((v) => {
-		const data = v.data?.[subscriptionName];
-		if (!data && v.error) throw v.error;
-		return data;
-	}), wonka.toObservable);
-}
-function stringifySelection(selection) {
-	return Object.entries(selection).filter(([key]) => key !== argsKey).reduce((acc, [key, value]) => {
-		if (typeof value === "object") {
-			if (value[argsKey]) {
-				const argsString = stringifyArgumentObjectToGraphqlList(value[argsKey]);
-				acc += `${key}${argsString} { ${stringifySelection(value)} }
-`;
-				return acc;
-			}
-			acc += `${key} {
-${stringifySelection(value)} }
-`;
-		} else acc += `${key}
-`;
-		return acc;
-	}, "");
-}
-function stringifyArgumentObjectToGraphqlList(args) {
-	const entries = Object.entries(args);
-	if (Array.isArray(args)) return `(${stringifyArgumentValue(args)})`;
-	if (entries.length > 0) return `(${entries.map(([key, value]) => `${key}: ${stringifyArgumentValue(value)}`).join(", ")})`;
-	return "";
-}
-function stringifyArgumentValue(arg) {
-	if (arg === null) return "null";
-	if (Array.isArray(arg)) return `[${arg.map(stringifyArgumentValue).join(", ")}]`;
-	switch (typeof arg) {
-		case "string": return `"${arg}"`;
-		case "number": return `${arg}`;
-		case "bigint": return `${arg}`;
-		case "boolean": return `${arg}`;
-		case "symbol": throw new Error("Cannot stringify a symbol to send as gql arg");
-		case "undefined": return "null";
-		case "object": return `{ ${Object.entries(arg).map(([key, value]) => `${key}: ${stringifyArgumentValue(value)}`).join(", ")} }`;
-		case "function": throw new Error("Cannot stringify a function to send as gql arg");
-	}
-}
-
-//#endregion
-//#region lib/client/liveQuery.ts
-function makeLiveQuery({ urqlClient, availableSubscriptions, forceReactivity }) {
-	return new Proxy({}, { get: (_target, prop) => {
-		return (input) => {
-			return makeGraphQLQueryRequest({
-				queryName: prop,
-				input,
-				client: urqlClient,
-				enableSubscription: availableSubscriptions.has(prop),
-				forceReactivity
-			});
-		};
-	} });
-}
-
-//#endregion
-//#region lib/client/mutation.ts
-function makeMutation({ urqlClient, forceReactivity }) {
-	return new Proxy({}, { get: (_target, prop) => {
-		return (input) => {
-			return makeGraphQLMutationRequest({
-				mutationName: prop,
-				input,
-				client: urqlClient,
-				forceReactivity
-			});
-		};
-	} });
-}
-
-//#endregion
-//#region lib/helpers/deepMap.ts
-/**
-* Recursively applies a mapping function to every value in a nested structure.
-*
-* This helper will traverse arrays and plain objects (objects with `constructor === Object`)
-* and apply the provided `fn` to any value that is not an array or a plain object.
-* - Arrays are mapped to new arrays (a fresh array is returned).
-* - Plain objects are traversed and their own enumerable properties are replaced in-place.
-* - Non-plain objects (e.g. Date, Map, Set, class instances, functions) are treated as leaves
-*   and passed directly to `fn`.
-* - `null` and `undefined` are passed to `fn`.
-* - Circular references are detected using a `WeakSet`. When a circular reference is encountered,
-*   the original reference is returned unchanged (it is not re-traversed or re-mapped).
-*
-* Note: Because plain objects are mutated in-place, callers who need immutability should first
-* clone the object graph or pass a deep-cloned input to avoid modifying the original.
-*
-* @param input - The value to traverse and map. May be any value (primitive, array, object, etc.).
-* @param fn - A function invoked for every non-array, non-plain-object value encountered.
-*             Receives the current value and should return the mapped value.
-* @returns The transformed structure: arrays are returned as new arrays, plain objects are the
-*          same object instances with their property values replaced, and other values are the
-*          result of `fn`.
-*
-* @example
-* // Map all primitive values to their string representation:
-* // const result = mapValuesDeep({ a: 1, b: [2, { c: 3 }] }, v => String(v));
-* // result => { a: "1", b: ["2", { c: "3" }] }
-*
-* @remarks
-* - Only plain objects (constructed by `Object`) are recursively traversed. This avoids
-*   unintentionally iterating internal structure of class instances or built-in collections.
-* - Circular structures are preserved by returning the original reference when detected.
-*/
-function mapValuesDeep(input, fn) {
-	const seen = /* @__PURE__ */ new WeakSet();
-	const recurse = (value) => {
-		if (Array.isArray(value)) return value.map(recurse);
-		if (value !== null && value !== void 0 && typeof value === "object" && value.constructor === Object) {
-			if (seen.has(value)) return value;
-			seen.add(value);
-			for (const key of Object.keys(value)) value[key] = recurse(value[key]);
-			return value;
-		}
-		return fn(value);
-	};
-	return recurse(input);
-}
-
-//#endregion
-//#region lib/client/nativeDateExchange.ts
-const dateIsoRegex = /^\d{4}-\d{2}-\d{2}(?:[Tt ]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:[Zz]|[+-]\d{2}:\d{2})?)?$/;
-const nativeDateExchange = ({ client, forward }) => {
-	return (operations$) => {
-		return (0, wonka.pipe)(forward(operations$), (0, wonka.map)((r) => {
-			r.data = mapValuesDeep(r.data, (value) => {
-				if (typeof value !== "string" || !dateIsoRegex.test(value)) return value;
-				const date = Date.parse(value);
-				if (!Number.isNaN(date)) return new Date(date);
-				return value;
-			});
-			return r;
-		}));
-	};
-};
-
-//#endregion
-//#region lib/client/query.ts
-function makeQuery({ urqlClient, forceReactivity }) {
-	return new Proxy({}, { get: (_target, prop) => {
-		return (input) => {
-			return makeGraphQLQueryRequest({
-				queryName: prop,
-				input,
-				client: urqlClient,
-				enableSubscription: false,
-				forceReactivity
-			});
-		};
-	} });
-}
-
-//#endregion
-//#region lib/client/subscription.ts
-function makeSubscription({ urqlClient, forceReactivity }) {
-	return new Proxy({}, { get: (_target, prop) => {
-		return (input) => {
-			return makeGraphQLSubscriptionRequest({
-				subscriptionName: prop,
-				input,
-				client: urqlClient,
-				forceReactivity
-			});
-		};
-	} });
-}
-
-//#endregion
 //#region lib/types/rumbleError.ts
 /**
 * An error that gets raised by rumble whenever something does not go according to plan.
@@ -939,10 +516,10 @@ const createAbilityBuilder = ({ db, actions, defaultLimit }) => {
 						/**
 						* Merges the current query filters with the provided filters for this call only
 						*/
-						function merge$2(p) {
+						function merge$1(p) {
 							return internalTransformer(mergeFilters(ret.query.many, p), p.limit);
 						}
-						ret.merge = merge$2;
+						ret.merge = merge$1;
 						return ret;
 					}
 					return { withContext: (userContext) => {
@@ -1157,7 +734,7 @@ const createWhereArgImplementer = ({ db, schemaBuilder, enumImplementer }) => {
 const clientCreatorImplementer = ({ builtSchema }) => {
 	const clientCreator = async ({ apiUrl, outputPath, rumbleImportPath, useExternalUrqlClient, removeExisting, forceReactivity }) => {
 		if (process.env.NODE_ENV !== "development") console.warn("Running rumble client generation in non development mode. Are you sure this is correct?");
-		await generateFromSchema({
+		await require_generate.generateFromSchema({
 			schema: builtSchema(),
 			outputPath,
 			rumbleImportPath,
@@ -2043,14 +1620,9 @@ export const db = drizzle(
 //#endregion
 exports.RumbleError = RumbleError;
 exports.RumbleErrorSafe = RumbleErrorSafe;
+exports.__toESM = __toESM;
 exports.assertFindFirstExists = assertFindFirstExists;
 exports.assertFirstEntryExists = assertFirstEntryExists;
-exports.generateFromSchema = generateFromSchema;
-exports.makeLiveQuery = makeLiveQuery;
-exports.makeMutation = makeMutation;
-exports.makeQuery = makeQuery;
-exports.makeSubscription = makeSubscription;
 exports.mapNullFieldsToUndefined = mapNullFieldsToUndefined;
-exports.nativeDateExchange = nativeDateExchange;
 exports.rumble = rumble;
 //# sourceMappingURL=index.cjs.map