zodselect 1.1.0 → 1.2.0

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

@@ -1,13 +1,21 @@
-import { ZodType, ZodUnion } from 'zod';
+import { ZodArray, ZodCatch, ZodDefault, ZodLazy, ZodNullable, ZodObject, ZodOptional, ZodRawShape, ZodType, ZodUnion } from 'zod';
 import { ZodSelect } from './select.js';
-export type ZodSelectAll<T extends ZodType<object> | ZodUnion> = {
+type Depth = [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+type FieldSelectAll<T, TDepth extends number> = TDepth extends 0 ? true : Unwrap<T> extends ZodObject<infer TShape, any> ? ObjectSelectAll<TShape, Depth[TDepth]> : Unwrap<T> extends ZodArray<infer TItem> ? Unwrap<TItem> extends ZodObject<infer TShape, any> ? ObjectSelectAll<TShape, Depth[TDepth]> : true : true;
+type ObjectSelectAll<TShape extends ZodRawShape, TDepth extends number> = {
+    [K in keyof TShape]-?: FieldSelectAll<TShape[K], TDepth>;
+};
+type Unwrap<T> = T extends ZodCatch<infer I> | ZodDefault<infer I> | ZodNullable<infer I> | ZodOptional<infer I> ? Unwrap<I> : T extends ZodLazy<infer I> ? Unwrap<I> : T;
+/** What {@link buildSelectObject} answers: nested for objects and arrays of objects, `true` for anything else. */
+export type ZodSelectAll<T extends ZodType<object> | ZodUnion> = Unwrap<T> extends ZodObject<infer TShape, any> ? ObjectSelectAll<TShape, 10> : {
     [K in keyof ZodSelect<T, true>]-?: true;
 };
 /**
  * Produces a runtime select-all object for the given Zod schema.
  *
- * Every scalar key is set to `true`. Nested object fields are recursively
- * expanded into nested select objects. Array fields remain `true`.
+ * Every scalar key is set to `true`. Nested object fields, and arrays of
+ * objects, are recursively expanded into nested select objects. Other arrays
+ * and records remain `true`.
  * For union schemas the result is the merged set of keys across all variants.
  *
  * @example
@@ -17,3 +25,4 @@ export type ZodSelectAll<T extends ZodType<object> | ZodUnion> = {
  * ```
  */
 export declare function buildSelectObject<T extends ZodType<object> | ZodUnion>(schema: T): ZodSelectAll<T>;
+export {};

package/dist/build-select-object.js

@@ -1,10 +1,11 @@
 import { ZodCatch, ZodDefault, ZodLazy, ZodNullable, ZodOptional } from 'zod';
-import { getInnerType, isZodObject, isZodUnion } from './utilities.js';
+import { getInnerType, isZodArray, isZodObject, isZodUnion } from './utilities.js';
 /**
  * Produces a runtime select-all object for the given Zod schema.
  *
- * Every scalar key is set to `true`. Nested object fields are recursively
- * expanded into nested select objects. Array fields remain `true`.
+ * Every scalar key is set to `true`. Nested object fields, and arrays of
+ * objects, are recursively expanded into nested select objects. Other arrays
+ * and records remain `true`.
  * For union schemas the result is the merged set of keys across all variants.
  *
  * @example
@@ -41,7 +42,8 @@ function collectKeys(schema, result, depth = 0) {
     schema = getInnerType(schema);
     if (isZodObject(schema)) {
         for (const key in schema.shape) {
-            const fieldInner = unwrapField(schema.shape[key]);
+            const field = unwrapField(schema.shape[key]);
+            const fieldInner = isZodArray(field) ? unwrapField(field.def.element) : field;
             if (isZodObject(fieldInner)) {
                 const nested = {};
                 collectKeys(fieldInner, nested, depth + 1);

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

@@ -94,12 +94,68 @@ describe('.buildSelectObject()', () => {
         });
         assert.deepStrictEqual(buildSelectObject(schema), { name: true, tags: true });
     });
-    it('should not expand arrays of objects', () => {
+    it('should expand the items of an array of objects', () => {
         const schema = z.object({
             items: z.array(z.object({ id: z.string(), value: z.number() })),
             name: z.string()
         });
-        assert.deepStrictEqual(buildSelectObject(schema), { items: true, name: true });
+        const select = buildSelectObject(schema);
+        const isTyped = true;
+        assert.ok(isTyped);
+        assert.deepStrictEqual(select, { items: { id: true, value: true }, name: true });
+    });
+    it('should expand an optional array of optional objects', () => {
+        const schema = z.object({
+            items: z.array(z.object({ id: z.string() }).optional()).optional()
+        });
+        const select = buildSelectObject(schema);
+        const isTyped = true;
+        assert.ok(isTyped);
+        assert.deepStrictEqual(select, { items: { id: true } });
+    });
+    it('should expand arrays of objects inside arrays of objects', () => {
+        const schema = z.object({
+            attachments: z.array(z.object({
+                history: z.array(z.object({ note: z.string(), uploadedBy: z.object({ _id: z.string(), username: z.string() }) })),
+                title: z.string()
+            }))
+        });
+        const select = buildSelectObject(schema);
+        const isTyped = true;
+        assert.ok(isTyped);
+        assert.deepStrictEqual(select, {
+            attachments: { history: { note: true, uploadedBy: { _id: true, username: true } }, title: true }
+        });
+    });
+    it('should type nested objects as nested selects', () => {
+        const schema = z.object({
+            client: z.object({ _id: z.string(), name: z.string() }).optional(),
+            title: z.string()
+        });
+        const select = buildSelectObject(schema);
+        const isTyped = true;
+        assert.ok(isTyped);
+        assert.deepStrictEqual(select, { client: { _id: true, name: true }, title: true });
+    });
+    it('should not expand records, or arrays of anything but objects', () => {
+        const schema = z.object({
+            byKey: z.record(z.string(), z.object({ id: z.string() })),
+            matrix: z.array(z.array(z.number())),
+            options: z.array(z.union([z.object({ a: z.string() }), z.object({ b: z.string() })])),
+            tags: z.array(z.string())
+        });
+        const select = buildSelectObject(schema);
+        const isTyped = true;
+        assert.ok(isTyped);
+        assert.deepStrictEqual(select, { byKey: true, matrix: true, options: true, tags: true });
+    });
+    it('should be a select the schema accepts', () => {
+        const schema = z.object({
+            client: z.object({ _id: z.string(), name: z.string() }),
+            items: z.array(z.object({ id: z.string() }))
+        });
+        const select = buildSelectObject(schema);
+        assert.deepStrictEqual(select, { client: { _id: true, name: true }, items: { id: true } });
     });
     it('should handle recursive schemas without infinite loop', () => {
         ;

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "zodselect",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "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",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/secure-data-systems/zod-select.git"
+    "url": "git+https://github.com/temelyos/zod-select.git"
   },
   "type": "module",
   "main": "dist/index.js",
@@ -25,8 +25,8 @@
     }
   },
   "devDependencies": {
-    "@secure-data-systems/eslint-config": "^1.0.38",
-    "@secure-data-systems/tsconfig": "^1.0.6",
+    "@temelyos/eslint-config": "^1.0.38",
+    "@temelyos/tsconfig": "^1.0.6",
     "@types/node": "^26.1.1",
     "tsx": "^4.23.1",
     "typescript": "npm:@typescript/typescript6@^6.0.2",