@fabriciogferreira/schema-to-query-string 0.1.1 → 0.1.2

package/package.json

@@ -1,14 +1,22 @@
 {
 	"name": "@fabriciogferreira/schema-to-query-string",
-	"description": "function for convert schema to Spatie Laravel Query Builder",
-	"version": "0.1.1",
-	"private": false,
-	"main": "dist/index.cjs",
-	"module": "dist/index.js",
-	"types": "dist/index.d.ts",
+	"version": "0.1.2",
+	"type": "module",
+	"license": "MIT",
+	"author": "Fabrício G. Ferreira <fabriciof481@gmail.com>",
+	"description": "Function for convert schema to Spatie Laravel Query Builder",
 	"files": [
-		"dist"
+		"src"
 	],
+	"keywords": [
+		"conversion",
+		"schema",
+		"query string"
+	],
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/fabriciogferreira/schema-to-query-string"
+	},
 	"scripts": {
 		"build": "tsc",
 		"test": "bun test",

package/src/index.ts

@@ -0,0 +1 @@
+export { schemaToQueryString } from './schema-to-query-string';

package/src/schema-to-query-string.ts

@@ -0,0 +1,76 @@
+//* Libraries imports
+import { ZodArray, ZodNullable, ZodObject } from "zod/v4";
+
+export const schemaToQueryString = (
+  schema: ZodObject,
+  rootResource: string,
+	includeKey: string = "include",
+	fieldsKey: string = "fields"
+) => {
+  const fields: Record<string, string[]> = {};
+  const includes = new Set<string>();
+
+  fields[rootResource] = [];
+
+  const walk = (
+    currentSchema: ZodObject,
+    resourcePath: string | null
+  ) => {
+    const currentFieldsKey = resourcePath ?? rootResource;
+
+    if (!fields[currentFieldsKey]) {
+      fields[currentFieldsKey] = [];
+    }
+
+    for (const key in currentSchema.shape) {
+      let rawField = currentSchema.shape[key];
+      
+			if (rawField instanceof ZodNullable) {
+				rawField = rawField.unwrap()
+			}
+      
+			if (rawField instanceof ZodObject || rawField instanceof ZodArray) {
+				let nextPath = resourcePath
+					? `${resourcePath}.${key}`
+					: key;
+
+        includes.add(nextPath);
+				
+				// ARRAY
+				if (rawField instanceof ZodArray) {
+					rawField = rawField.unwrap()
+				}
+				
+				// OBJETO
+				if (rawField instanceof ZodObject) {
+					walk(rawField, nextPath);
+				}
+
+				continue;
+			}
+
+      // CAMPO SIMPLES
+      fields[currentFieldsKey].push(key);
+    }
+  };
+
+  walk(schema, null);
+
+  const queryParts: string[] = [];
+
+	for (const resource in fields) {
+    if (fields[resource].length > 0) {
+      queryParts.push(
+        `${fieldsKey}[${resource}]=${fields[resource].join(",")}`
+      );
+    }
+  }
+
+  if (includes.size) {
+    queryParts.push(
+      `${includeKey}=${Array.from(includes).join(",")}`
+    );
+  }
+
+  return "?" + queryParts.join("&");
+};

package/dist/tests/schema-to-query-string.test.js

@@ -1,159 +0,0 @@
-//* Libraries imports
-import { it, expect } from "bun:test";
-import z from "zod/v4";
-import fastCartesian from "fast-cartesian";
-import { PowerSet } from 'js-combinatorics';
-//* Utils imports
-import { schemaToQueryString } from "../src";
-const partialObjects = [
-    [
-        {
-            rootOne: z.string(),
-        },
-        "fields[root]=rootOne"
-    ],
-    [
-        {
-            rootTwo: z.string(),
-        },
-        "fields[root]=rootTwo"
-    ],
-    [
-        {
-            rootObject: z.object({
-                subOne: z.number(),
-            }),
-        },
-        "fields[rootObject]=subOne&include=rootObject"
-    ],
-    [
-        {
-            rootObject: z.object({
-                subTwo: z.number(),
-            }),
-        },
-        "fields[rootObject]=subTwo&include=rootObject"
-    ],
-    [
-        {
-            rootNullableObject: z.object({
-                subOne: z.number(),
-            }).nullable(),
-        },
-        "fields[rootNullableObject]=subOne&include=rootNullableObject"
-    ],
-    [
-        {
-            rootNullableObject: z.object({
-                subTwo: z.number(),
-            }).nullable(),
-        },
-        "fields[rootNullableObject]=subTwo&include=rootNullableObject"
-    ],
-    [
-        {
-            rootArrayObject: z.object({
-                subOne: z.number(),
-            }).array(),
-        },
-        "fields[rootArrayObject]=subOne&include=rootArrayObject"
-    ],
-    [
-        {
-            rootArrayObject: z.object({
-                subTwo: z.number(),
-            }).array(),
-        },
-        "fields[rootArrayObject]=subTwo&include=rootArrayObject"
-    ],
-];
-function unwrapObject(schema) {
-    if (schema instanceof z.ZodObject) {
-        return schema;
-    }
-    if (schema instanceof z.ZodNullable) {
-        const inner = schema.unwrap();
-        return inner instanceof z.ZodObject ? inner : null;
-    }
-    if (schema instanceof z.ZodArray) {
-        const inner = schema.unwrap();
-        return inner instanceof z.ZodObject ? inner : null;
-    }
-    return null;
-}
-function isNullable(schema) {
-    return schema instanceof z.ZodNullable;
-}
-function deepExtendZod(base, extension) {
-    const newShape = { ...base.shape };
-    for (const key in extension) {
-        const baseField = newShape[key];
-        const extField = extension[key];
-        const baseObj = baseField ? unwrapObject(baseField) : null;
-        const extObj = unwrapObject(extField);
-        if (baseObj && extObj) {
-            const merged = deepExtendZod(baseObj, extObj.shape);
-            const shouldBeNullable = isNullable(baseField) || isNullable(extField);
-            newShape[key] = shouldBeNullable
-                ? merged.nullable()
-                : merged;
-        }
-        else {
-            newShape[key] = extField;
-        }
-    }
-    return z.object(newShape);
-}
-const schemaCombinations = [...new PowerSet(partialObjects)];
-const schemaCases = schemaCombinations.map((objects) => {
-    let schema = z.object({});
-    let fields = {};
-    let includes = new Set([]);
-    let expectedQueryString = '';
-    objects.forEach(([object, queryString]) => {
-        //@ts-expect-error
-        schema = deepExtendZod(schema, object);
-        const params = queryString.split("&");
-        params.forEach((param) => {
-            const [key, values] = param.split("=");
-            if (key.startsWith("include")) {
-                values.split(',').map(value => includes.add(value));
-            }
-            if (key.startsWith("fields")) {
-                if (!(key in fields))
-                    fields[key] = new Set([]);
-                values.split(',').map(value => fields[key].add(value));
-            }
-        });
-    });
-    let includeValues = Array.from(includes).join(',');
-    let includeQueryString = includeValues ? `include=${Array.from(includes).join(',')}` : '';
-    let filtersQueryString = Object.entries(fields).map(([key, values]) => `${key}=${Array.from(values).join(',')}`).join('&');
-    expectedQueryString = '?' + [filtersQueryString, includeQueryString].filter(Boolean).join('&');
-    return [schema, expectedQueryString];
-});
-const objectNameCases = fastCartesian([
-    // ["fields"],
-    ["fields", "alternativeKeyForFields"],
-    // [undefined, "", "fields", "alternativeKeyForFields"],
-    // ["include"],
-    ["include", "alternativeKeyForInclude"],
-    // [undefined, "", "include", "alternativeKeyForInclude"],
-]);
-const combinations = fastCartesian([
-    objectNameCases,
-    schemaCases
-]);
-const cases = combinations.map(([config, [schema, expectedQueryString]]) => {
-    const fieldKey = config[0] === "" ? "vazio" : config[0] === undefined ? "undefined" : config[0];
-    const includeKey = config[1] === "" ? "vazio" : config[1] === undefined ? "undefined" : config[1];
-    return [`${fieldKey},${includeKey}`, expectedQueryString, fieldKey, includeKey, schema];
-});
-it.each(cases)("when config is %s and should %s", (_, expected, fieldKey, includeKey, schema) => {
-    expected = expected.replace("include", includeKey);
-    expected = expected.replaceAll("fields", fieldKey);
-    const received = schemaToQueryString(schema, "root", includeKey, fieldKey);
-    // console.log("======================================================================================================")
-    // console.log(received, expected)
-    expect(received).toBe(expected);
-});