@m1212e/rumble 0.12.17 → 0.12.19

package/out/index.cjs

@@ -23,6 +23,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 //#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");
 let graphql = require("graphql");
 let es_toolkit = require("es-toolkit");
 let wonka = require("wonka");
@@ -46,25 +48,30 @@ __pothos_plugin_smart_subscriptions = __toESM(__pothos_plugin_smart_subscription
 let graphql_scalars = require("graphql-scalars");
 
 //#region lib/client/generate/client.ts
-function generateClient({ apiUrl, rumbleImportPath, useExternalUrqlClient, availableSubscriptions }) {
+function generateClient({ apiUrl, rumbleImportPath, useExternalUrqlClient, availableSubscriptions, schema }) {
 	const imports = [];
 	let code = "";
 	if (typeof useExternalUrqlClient === "string") imports.push(`import { urqlClient } from "${useExternalUrqlClient}";`);
-	else {
-		imports.push(`import { Client, fetchExchange } from '@urql/core';`);
-		imports.push(`import { cacheExchange } from '@urql/exchange-graphcache';`);
-	}
+	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 { makeLiveQuery, makeMutation, makeSubscription, makeQuery } from '${rumbleImportPath}';`);
-	if (!useExternalUrqlClient) code += `
-const urqlClient = new Client({
+	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({}), fetchExchange],
+  exchanges: [cacheExchange({
+     // @ts-ignore
+     schema: ${schema ? (0, devalue.uneval)((0, __urql_introspection.minifyIntrospectionQuery)((0, __urql_introspection.getIntrospectedSchema)(schema))) : "undefined"}
+   }), nativeDateExchange, fetchExchange],
   fetchOptions: {
     credentials: "include",
   },
   requestPolicy: "cache-and-network",
-});
+}  
+`;
+	if (!useExternalUrqlClient) code += `
+const urqlClient = new Client(defaultOptions);
 `;
 	code += `
 export const client = {
@@ -227,6 +234,7 @@ export type ${key} = ${rep};
 	}
 	const c = generateClient({
 		apiUrl,
+		schema,
 		useExternalUrqlClient,
 		rumbleImportPath,
 		availableSubscriptions: new Set(Object.keys(schema.getSubscriptionType()?.getFields() || {}))
@@ -241,8 +249,8 @@ export type ${key} = ${rep};
 const argsKey = "__args";
 function makeGraphQLQuery({ queryName, input, client, enableSubscription = false }) {
 	const otwQueryName = `${(0, es_toolkit.capitalize)(queryName)}Query`;
-	const argsString = stringifyArgumentObjectToGraphqlList(input[argsKey] ?? {});
-	const operationString = (operationVerb) => `${operationVerb} ${otwQueryName} { ${queryName}${argsString} { ${stringifySelection(input)} }}`;
+	const argsString = stringifyArgumentObjectToGraphqlList(input?.[argsKey] ?? {});
+	const operationString = (operationVerb) => `${operationVerb} ${otwQueryName} { ${queryName}${argsString} ${input ? `{ ${stringifySelection(input)} }` : ""}}`;
 	let awaitedReturnValueReference;
 	const observable = (0, wonka.pipe)((0, wonka.merge)([client.query(operationString("query"), {}), enableSubscription ? client.subscription(operationString("subscription"), {}) : wonka.empty]), (0, wonka.map)((v) => {
 		const data = v.data?.[queryName];
@@ -349,6 +357,73 @@ function makeMutation({ urqlClient }) {
 	} });
 }
 
+//#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 }) {
@@ -1939,5 +2014,6 @@ exports.makeMutation = makeMutation;
 exports.makeQuery = makeQuery;
 exports.makeSubscription = makeSubscription;
 exports.mapNullFieldsToUndefined = mapNullFieldsToUndefined;
+exports.nativeDateExchange = nativeDateExchange;
 exports.rumble = rumble;
 //# sourceMappingURL=index.cjs.map