zodselect 1.0.11 → 1.0.13

package/dist/build-select-object.d.ts

@@ -0,0 +1,19 @@
+import { ZodType, ZodUnion } from 'zod';
+import { ZodSelect } from './select.js';
+export type ZodSelectAll<T extends ZodType<object> | ZodUnion> = {
+    [K in keyof ZodSelect<T, true>]-?: true;
+};
+/**
+ * Produces a runtime select-all object for the given Zod schema.
+ *
+ * Every top-level key is set to `true`, which tells the server to include
+ * that field in the response.  For union schemas the result is the merged
+ * set of keys across all variants.
+ *
+ * @example
+ * ```ts
+ * const select = buildSelectObject(AuthenticationService);
+ * // { name: true, type: true, isEnabled: true, ... }
+ * ```
+ */
+export declare function buildSelectObject<T extends ZodType<object> | ZodUnion>(schema: T): ZodSelectAll<T>;

package/dist/build-select-object.js

@@ -0,0 +1,36 @@
+import { getInnerType, isZodObject, isZodUnion } from './utilities.js';
+/**
+ * Produces a runtime select-all object for the given Zod schema.
+ *
+ * Every top-level key is set to `true`, which tells the server to include
+ * that field in the response.  For union schemas the result is the merged
+ * set of keys across all variants.
+ *
+ * @example
+ * ```ts
+ * const select = buildSelectObject(AuthenticationService);
+ * // { name: true, type: true, isEnabled: true, ... }
+ * ```
+ */
+export function buildSelectObject(schema) {
+    const result = {};
+    collectKeys(schema, result);
+    return result;
+}
+function collectKeys(schema, result) {
+    schema = getInnerType(schema);
+    if (isZodObject(schema)) {
+        for (const key in schema.shape) {
+            result[key] = true;
+        }
+    }
+    else if (isZodUnion(schema)) {
+        for (const option of schema.options) {
+            collectKeys(option, result);
+        }
+    }
+    else if (schema.def.type === 'intersection') {
+        collectKeys(schema.def.left, result);
+        collectKeys(schema.def.right, result);
+    }
+}

package/dist/build-select-object.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/build-select-object.spec.js

@@ -0,0 +1,58 @@
+import { strict as assert } from 'assert';
+import { describe, it } from 'node:test';
+import { z } from 'zod';
+import { buildSelectObject } from './build-select-object.js';
+describe('.buildSelectObject()', () => {
+    it('should return all keys set to true for a flat object', () => {
+        const schema = z.object({
+            age: z.number(),
+            name: z.string()
+        });
+        assert.deepStrictEqual(buildSelectObject(schema), { age: true, name: true });
+    });
+    it('should merge keys from all union members', () => {
+        const schema = z.union([
+            z.object({ type: z.literal('a'), valueA: z.string() }),
+            z.object({ type: z.literal('b'), valueB: z.number() })
+        ]);
+        assert.deepStrictEqual(buildSelectObject(schema), {
+            type: true,
+            valueA: true,
+            valueB: true
+        });
+    });
+    it('should merge keys from an intersection', () => {
+        const schema = z.intersection(z.object({ a: z.string() }), z.object({ b: z.number() }));
+        assert.deepStrictEqual(buildSelectObject(schema), { a: true, b: true });
+    });
+    it('should unwrap optional/nullable wrappers', () => {
+        const inner = z.object({ id: z.string(), value: z.number() });
+        const schema = inner.optional();
+        assert.deepStrictEqual(buildSelectObject(schema), { id: true, value: true });
+    });
+    it('should unwrap lazy schemas', () => {
+        const schema = z.lazy(() => z.object({ bar: z.number(), foo: z.string() }));
+        assert.deepStrictEqual(buildSelectObject(schema), { bar: true, foo: true });
+    });
+    it('should handle nested unions inside intersection', () => {
+        const schema = z.intersection(z.union([
+            z.object({ a: z.string() }),
+            z.object({ b: z.number() })
+        ]), z.object({ c: z.boolean() }));
+        assert.deepStrictEqual(buildSelectObject(schema), {
+            a: true,
+            b: true,
+            c: true
+        });
+    });
+    it('should only collect top-level keys (not nested)', () => {
+        const schema = z.object({
+            active: z.boolean(),
+            user: z.object({
+                age: z.number(),
+                name: z.string()
+            })
+        });
+        assert.deepStrictEqual(buildSelectObject(schema), { active: true, user: true });
+    });
+});

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export * from './build-select-object.js';
 export * from './build-select-schema.js';
 export * from './merge-select.js';
 export * from './refine-schema.js';

package/dist/index.js

@@ -1,3 +1,4 @@
+export * from './build-select-object.js';
 export * from './build-select-schema.js';
 export * from './merge-select.js';
 export * from './refine-schema.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zodselect",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "description": "Type-safe selection utility built on top of Zod. Allows for strongly typed field selection, schema merging, and runtime refinement for frontend or backend use.",
   "author": "SecureDataSystems",
   "license": "MIT",