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

package/dist/src/index.js

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

package/dist/src/schema-to-query-string.js

@@ -0,0 +1,47 @@
+//* Libraries imports
+import { ZodArray, ZodNullable, ZodObject } from "zod/v4";
+export const schemaToQueryString = (schema, rootResource, includeKey = "include", fieldsKey = "fields") => {
+    const fields = {};
+    const includes = new Set();
+    fields[rootResource] = [];
+    const walk = (currentSchema, resourcePath) => {
+        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 = [];
+    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

@@ -0,0 +1,159 @@
+//* 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);
+});

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@fabriciogferreira/schema-to-query-string",
 	"description": "function for convert schema to Spatie Laravel Query Builder",
-	"version": "0.1.0",
+	"version": "0.1.1",
 	"private": false,
 	"main": "dist/index.cjs",
 	"module": "dist/index.js",