@m1212e/rumble 0.15.4 → 0.16.2

package/out/index.mjs

@@ -1,12 +1,8 @@
-import { access, mkdir, rm, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { getIntrospectedSchema, minifyIntrospectionQuery } from "@urql/introspection";
-import { uneval } from "devalue";
-import { GraphQLEnumType, GraphQLError, GraphQLInputObjectType, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLScalarType } from "graphql";
-import { capitalize, cloneDeep, debounce, merge, toMerged } from "es-toolkit";
-import { empty, map, merge as merge$1, onPush, pipe, share, take, toObservable, toPromise } from "wonka";
+import { t as generateFromSchema } from "./generate-lRQdmIB7.mjs";
+import { GraphQLError } from "graphql";
 import { EnvelopArmorPlugin } from "@escape.tech/graphql-armor";
 import { useDisableIntrospection } from "@graphql-yoga/plugin-disable-introspection";
+import { capitalize, cloneDeep, debounce, merge, toMerged } from "es-toolkit";
 import { createPubSub, createYoga } from "graphql-yoga";
 import { useSofa } from "sofa-api";
 import { One, count, relationsFilterToSQL, sql } from "drizzle-orm";
@@ -20,425 +16,6 @@ import DrizzlePlugin from "@pothos/plugin-drizzle";
 import SmartSubscriptionsPlugin, { subscribeOptionsFromIterator } from "@pothos/plugin-smart-subscriptions";
 import { DateResolver, DateTimeISOResolver, JSONResolver } from "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 GraphQLObjectType) return makeTSTypeFromObject(model);
-	else if (model instanceof GraphQLScalarType) return mapGraphqlScalarToTSTypeString(model);
-	else if (model instanceof GraphQLEnumType) return makeStringLiteralUnionFromEnum(model);
-	else if (model instanceof 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 GraphQLList) {
-			isList = true;
-			returnType = returnType.ofType;
-		}
-		if (returnType instanceof GraphQLNonNull) {
-			isNonNullReturnType = true;
-			returnType = returnType.ofType;
-		}
-	}
-	let returnTypeString = returnType.name;
-	if (isList) returnTypeString += "[]";
-	if (!isNonNullReturnType) returnTypeString += " | null";
-	const isRelationType = returnType instanceof 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 GraphQLList) {
-			isList = true;
-			returnType = returnType.ofType;
-		}
-		if (returnType instanceof 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 GraphQLNonNull) {
-		isNullable = false;
-		arg = arg.ofType;
-	}
-	if (arg instanceof GraphQLInputObjectType || arg instanceof 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 access(outputPath);
-		await rm(outputPath, {
-			recursive: true,
-			force: true
-		});
-	} catch (_error) {}
-	await 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([writeFile(join(outputPath, "client.ts"), `${imports.join("\n")}\n${code}`), writeFile(join(outputPath, `${schemaFileName}.ts`), `// @ts-ignore
-export const schema = ${uneval(minifyIntrospectionQuery(getIntrospectedSchema(schema)))}`)]);
-}
-
-//#endregion
-//#region lib/client/request.ts
-const argsKey = "__args";
-function makeGraphQLQueryRequest({ queryName, input, client, enableSubscription = false, forceReactivity }) {
-	const otwQueryName = `${capitalize(queryName)}Query`;
-	const argsString = stringifyArgumentObjectToGraphqlList(input?.[argsKey] ?? {});
-	const operationString = (operationVerb) => `${operationVerb} ${otwQueryName} { ${queryName}${argsString} ${input ? `{ ${stringifySelection(input)} }` : ""}}`;
-	const awaitedReturnValueReference = {};
-	const source = pipe(merge$1([client.query(operationString("query"), {}), enableSubscription ? client.subscription(operationString("subscription"), {}) : empty]), share, map((v) => {
-		const data = v.data?.[queryName];
-		if (!data && v.error) throw v.error;
-		return data;
-	}), onPush((data) => {
-		if (typeof data === "object" && data !== null && typeof forceReactivity === "boolean" && forceReactivity) Object.assign(awaitedReturnValueReference, data);
-	}));
-	const observable = toObservable(source);
-	const promise = toPromise(pipe(source, take(1), 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 ${`${capitalize(mutationName)}Mutation`} { ${mutationName}${stringifyArgumentObjectToGraphqlList(input[argsKey] ?? {})} { ${stringifySelection(input)} }}`;
-	const response = pipe(client.mutation(operationString, {}), map((v) => {
-		const data = v.data?.[mutationName];
-		if (!data && v.error) throw v.error;
-		return data;
-	}));
-	const observable = toObservable(response);
-	const promise = toPromise(pipe(response, take(1)));
-	Object.assign(promise, observable);
-	return promise;
-}
-function makeGraphQLSubscriptionRequest({ subscriptionName, input, client, forceReactivity }) {
-	const operationString = `subscription ${`${capitalize(subscriptionName)}Subscription`} { ${subscriptionName}${stringifyArgumentObjectToGraphqlList(input[argsKey] ?? {})} { ${stringifySelection(input)} }}`;
-	return pipe(client.subscription(operationString, {}), map((v) => {
-		const data = v.data?.[subscriptionName];
-		if (!data && v.error) throw v.error;
-		return data;
-	}), 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 pipe(forward(operations$), 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.
@@ -912,10 +489,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) => {
@@ -2014,5 +1591,5 @@ export const db = drizzle(
 };
 
 //#endregion
-export { RumbleError, RumbleErrorSafe, assertFindFirstExists, assertFirstEntryExists, generateFromSchema, makeLiveQuery, makeMutation, makeQuery, makeSubscription, mapNullFieldsToUndefined, nativeDateExchange, rumble };
+export { RumbleError, RumbleErrorSafe, assertFindFirstExists, assertFirstEntryExists, mapNullFieldsToUndefined, rumble };
 //# sourceMappingURL=index.mjs.map