@chnak/zod-to-markdown 1.0.2 → 1.0.4

package/lib/index.js

@@ -26,19 +26,24 @@ function zodSchemaToTable(schema) {
 exports.zodSchemaToTable = zodSchemaToTable;
 /**
  * 递归收集所有嵌套字段
+ * @param wrapperType - 当处于 Optional/Nullable 包装内部时，传入 'Optional' 或 'Nullable'
  */
-function collectFields(schema, prefix, fields) {
+function collectFields(schema, prefix, fields, wrapperType) {
     // 处理 Optional - 包装类型
     if (schema instanceof zod_1.z.ZodOptional) {
-        const innerType = getTypeString(schema.unwrap());
+        const inner = schema.unwrap();
         // 对于简单类型直接包装
-        if (schema.unwrap() instanceof zod_1.z.ZodObject || schema.unwrap() instanceof zod_1.z.ZodArray) {
-            collectFields(schema.unwrap(), prefix, fields);
+        if (inner instanceof zod_1.z.ZodObject || inner instanceof zod_1.z.ZodArray) {
+            collectFields(inner, prefix, fields, 'Optional');
+        }
+        else if (inner instanceof zod_1.z.ZodUnion || inner instanceof zod_1.z.ZodDiscriminatedUnion || inner instanceof zod_1.z.ZodIntersection) {
+            // 嵌套的复杂类型也需要展开
+            collectFields(inner, prefix, fields, 'Optional');
         }
         else {
             fields.push({
                 path: prefix,
-                type: `Optional<${innerType}>`,
+                type: `Optional<${getTypeString(inner)}>`,
                 description: schema.description || '-',
             });
         }
@@ -46,14 +51,18 @@ function collectFields(schema, prefix, fields) {
     }
     // 处理 Nullable - 包装类型
     if (schema instanceof zod_1.z.ZodNullable) {
-        const innerType = getTypeString(schema.unwrap());
-        if (schema.unwrap() instanceof zod_1.z.ZodObject || schema.unwrap() instanceof zod_1.z.ZodArray) {
-            collectFields(schema.unwrap(), prefix, fields);
+        const inner = schema.unwrap();
+        if (inner instanceof zod_1.z.ZodObject || inner instanceof zod_1.z.ZodArray) {
+            collectFields(inner, prefix, fields, 'Nullable');
+        }
+        else if (inner instanceof zod_1.z.ZodUnion || inner instanceof zod_1.z.ZodDiscriminatedUnion || inner instanceof zod_1.z.ZodIntersection) {
+            // 嵌套的复杂类型也需要展开
+            collectFields(inner, prefix, fields, 'Nullable');
         }
         else {
             fields.push({
                 path: prefix,
-                type: `Nullable<${innerType}>`,
+                type: `Nullable<${getTypeString(inner)}>`,
                 description: schema.description || '-',
             });
         }
@@ -72,13 +81,85 @@ function collectFields(schema, prefix, fields) {
             const innerFields = [];
             collectFields(element, '', innerFields);
             innerFields.forEach(field => {
+                const fieldPath = field.path || 'value';
                 fields.push({
-                    path: `${prefix}[]`,
-                    type: field.path || getTypeString(element),
+                    path: `${prefix}[].${fieldPath}`,
+                    type: field.type,
                     description: field.description,
                 });
             });
         }
+        else if (element instanceof zod_1.z.ZodUnion || element instanceof zod_1.z.ZodDiscriminatedUnion) {
+            // 数组元素是 Union 类型时，展开每个选项
+            element.options.forEach((opt, index) => {
+                // 对于 ZodOptional/ZodNullable，保留包装类型信息
+                if (opt instanceof zod_1.z.ZodOptional || opt instanceof zod_1.z.ZodNullable) {
+                    const typeStr = getTypeString(opt);
+                    const inner = opt instanceof zod_1.z.ZodOptional ? opt.unwrap() : opt.unwrap();
+                    if (inner instanceof zod_1.z.ZodObject || inner instanceof zod_1.z.ZodIntersection) {
+                        const innerFields = [];
+                        collectFields(inner, '', innerFields);
+                        innerFields.forEach(field => {
+                            fields.push({
+                                path: `${prefix}[].${field.path} (option ${index + 1})`,
+                                type: field.type,
+                                description: field.description,
+                            });
+                        });
+                    }
+                    else {
+                        fields.push({
+                            path: `${prefix}[] (option ${index + 1})`,
+                            type: typeStr,
+                            description: opt.description || '-',
+                        });
+                    }
+                }
+                else if (opt instanceof zod_1.z.ZodObject || opt instanceof zod_1.z.ZodIntersection) {
+                    // 对象类型或交叉类型，递归展开
+                    const innerFields = [];
+                    collectFields(opt, '', innerFields);
+                    innerFields.forEach(field => {
+                        fields.push({
+                            path: `${prefix}[].${field.path} (option ${index + 1})`,
+                            type: field.type,
+                            description: field.description,
+                        });
+                    });
+                }
+                else {
+                    // 其他简单类型
+                    fields.push({
+                        path: `${prefix}[] (option ${index + 1})`,
+                        type: getTypeString(opt),
+                        description: opt.description || '-',
+                    });
+                }
+            });
+        }
+        else if (element instanceof zod_1.z.ZodOptional) {
+            // 数组元素是 Optional 类型时，展开内部类型
+            const inner = element.unwrap();
+            if (inner instanceof zod_1.z.ZodObject) {
+                const innerFields = [];
+                collectFields(inner, '', innerFields);
+                innerFields.forEach(field => {
+                    const fieldPath = field.path || 'value';
+                    fields.push({
+                        path: `${prefix}[].${fieldPath}`,
+                        type: `Optional<${field.type}>`,
+                        description: field.description,
+                    });
+                });
+            }
+            else {
+                fields.push({
+                    path: `${prefix}[]`,
+                    type: `Optional<${getTypeString(inner)}>`,
+                    description: element.description || '-',
+                });
+            }
+        }
         else {
             // 非对象数组，保持原样
             fields.push({
@@ -95,7 +176,128 @@ function collectFields(schema, prefix, fields) {
         Object.keys(shape).forEach(key => {
             const subSchema = shape[key];
             const newPath = prefix ? `${prefix}.${key}` : key;
-            collectFields(subSchema, newPath, fields);
+            collectFields(subSchema, newPath, fields, wrapperType);
+        });
+        return;
+    }
+    // 处理 ZodUnion - 展开每个选项
+    if (schema instanceof zod_1.z.ZodUnion) {
+        schema.options.forEach((opt, index) => {
+            // 对于 ZodOptional/ZodNullable，保留包装类型信息
+            if (opt instanceof zod_1.z.ZodOptional || opt instanceof zod_1.z.ZodNullable) {
+                const typeStr = getTypeString(opt);
+                const innerWrapperType = opt instanceof zod_1.z.ZodOptional ? 'Optional' : 'Nullable';
+                const inner = opt instanceof zod_1.z.ZodOptional ? opt.unwrap() : opt.unwrap();
+                // 只有内部是对象或交叉类型才展开，否则直接使用类型字符串
+                if (inner instanceof zod_1.z.ZodObject || inner instanceof zod_1.z.ZodIntersection) {
+                    const innerFields = [];
+                    collectFields(inner, '', innerFields, innerWrapperType);
+                    innerFields.forEach(field => {
+                        fields.push({
+                            path: field.path ? `${prefix} (option ${index + 1}): ${field.path}` : `${prefix} (option ${index + 1})`,
+                            type: field.type,
+                            description: field.description,
+                        });
+                    });
+                }
+                else {
+                    fields.push({
+                        path: `${prefix} (option ${index + 1})`,
+                        type: typeStr,
+                        description: opt.description || '-',
+                    });
+                }
+            }
+            else if (opt instanceof zod_1.z.ZodObject || opt instanceof zod_1.z.ZodIntersection) {
+                // 对象类型或交叉类型，递归展开
+                const innerFields = [];
+                collectFields(opt, '', innerFields);
+                innerFields.forEach(field => {
+                    fields.push({
+                        path: field.path ? `${prefix} (option ${index + 1}): ${field.path}` : `${prefix} (option ${index + 1})`,
+                        type: field.type,
+                        description: field.description,
+                    });
+                });
+            }
+            else {
+                // 其他简单类型
+                fields.push({
+                    path: `${prefix} (option ${index + 1})`,
+                    type: getTypeString(opt),
+                    description: opt.description || '-',
+                });
+            }
+        });
+        return;
+    }
+    // 处理 ZodDiscriminatedUnion - 类似 Union 但有关联键
+    if (schema instanceof zod_1.z.ZodDiscriminatedUnion) {
+        schema.options.forEach((opt, index) => {
+            // 对于 ZodOptional/ZodNullable，保留包装类型信息
+            if (opt instanceof zod_1.z.ZodOptional || opt instanceof zod_1.z.ZodNullable) {
+                const typeStr = getTypeString(opt);
+                const innerWrapperType = opt instanceof zod_1.z.ZodOptional ? 'Optional' : 'Nullable';
+                const inner = opt instanceof zod_1.z.ZodOptional ? opt.unwrap() : opt.unwrap();
+                if (inner instanceof zod_1.z.ZodObject || inner instanceof zod_1.z.ZodIntersection) {
+                    const innerFields = [];
+                    collectFields(inner, '', innerFields, innerWrapperType);
+                    innerFields.forEach(field => {
+                        fields.push({
+                            path: field.path ? `${prefix} (option ${index + 1}): ${field.path}` : `${prefix} (option ${index + 1})`,
+                            type: field.type,
+                            description: field.description,
+                        });
+                    });
+                }
+                else {
+                    fields.push({
+                        path: `${prefix} (option ${index + 1})`,
+                        type: typeStr,
+                        description: opt.description || '-',
+                    });
+                }
+            }
+            else if (opt instanceof zod_1.z.ZodObject || opt instanceof zod_1.z.ZodIntersection) {
+                const innerFields = [];
+                collectFields(opt, '', innerFields);
+                innerFields.forEach(field => {
+                    fields.push({
+                        path: field.path ? `${prefix} (option ${index + 1}): ${field.path}` : `${prefix} (option ${index + 1})`,
+                        type: field.type,
+                        description: field.description,
+                    });
+                });
+            }
+            else {
+                fields.push({
+                    path: `${prefix} (option ${index + 1})`,
+                    type: getTypeString(opt),
+                    description: opt.description || '-',
+                });
+            }
+        });
+        return;
+    }
+    // 处理 ZodIntersection - 展开左右两部分
+    if (schema instanceof zod_1.z.ZodIntersection) {
+        const leftFields = [];
+        const rightFields = [];
+        collectFields(schema._def.left, '', leftFields);
+        collectFields(schema._def.right, '', rightFields);
+        leftFields.forEach(field => {
+            fields.push({
+                path: `${prefix}: ${field.path} (Left)`,
+                type: field.type,
+                description: field.description,
+            });
+        });
+        rightFields.forEach(field => {
+            fields.push({
+                path: `${prefix}: ${field.path} (Right)`,
+                type: field.type,
+                description: field.description,
+            });
         });
         return;
     }
@@ -119,9 +321,16 @@ function collectFields(schema, prefix, fields) {
         return;
     }
     // 其他类型直接添加
+    let typeStr = getTypeString(schema);
+    if (wrapperType === 'Optional' && !typeStr.startsWith('Optional<') && !typeStr.startsWith('Nullable<')) {
+        typeStr = `Optional<${typeStr}>`;
+    }
+    else if (wrapperType === 'Nullable' && !typeStr.startsWith('Optional<') && !typeStr.startsWith('Nullable<')) {
+        typeStr = `Nullable<${typeStr}>`;
+    }
     fields.push({
         path: prefix,
-        type: getTypeString(schema),
+        type: typeStr,
         description: schema.description || '-',
     });
 }

package/lib/index.test.js

@@ -8,33 +8,33 @@ describe('zodSchemaToMarkdown', () => {
             name: zod_1.z.string(),
             age: zod_1.z.number(),
         });
-        const expected = `- name
-  - String
-- age
-  - Number
+        const expected = `- name
+  - String
+- age
+  - Number
 `;
         expect((0, index_1.zodSchemaToMarkdown)(schema)).toBe(expected);
     });
     it('should convert an array schema to markdown', () => {
         const schema = zod_1.z.array(zod_1.z.string());
-        const expected = `- Array
-  - String
+        const expected = `- Array
+  - String
 `;
         expect((0, index_1.zodSchemaToMarkdown)(schema)).toBe(expected);
     });
     it('should convert a union schema to markdown', () => {
         const schema = zod_1.z.union([zod_1.z.string(), zod_1.z.number()]);
-        const expected = `- Union
-  - String
-  |
-  - Number
+        const expected = `- Union
+  - String
+  |
+  - Number
 `;
         expect((0, index_1.zodSchemaToMarkdown)(schema)).toBe(expected);
     });
     it('should convert ZodEffects (transform) to markdown', () => {
         const schema = zod_1.z.string().transform(val => val.length);
-        const expected = `- Effects (transform)
-  - String
+        const expected = `- Effects (transform)
+  - String
 `;
         expect((0, index_1.zodSchemaToMarkdown)(schema)).toBe(expected);
     });
@@ -43,90 +43,90 @@ describe('zodSchemaToMarkdown', () => {
             zod_1.z.object({ type: zod_1.z.literal('a'), a: zod_1.z.string() }),
             zod_1.z.object({ type: zod_1.z.literal('b'), b: zod_1.z.number() })
         ]);
-        const expected = `- DiscriminatedUnion (key: type)
-  - type
-    - Literal: "a"
-  - a
-    - String
-  |
-  - type
-    - Literal: "b"
-  - b
-    - Number
+        const expected = `- DiscriminatedUnion (key: type)
+  - type
+    - Literal: "a"
+  - a
+    - String
+  |
+  - type
+    - Literal: "b"
+  - b
+    - Number
 `;
         expect((0, index_1.zodSchemaToMarkdown)(schema)).toBe(expected);
     });
     it('should convert ZodIntersection to markdown', () => {
         const schema = zod_1.z.object({ a: zod_1.z.string() }).and(zod_1.z.object({ b: zod_1.z.number() }));
-        const expected = `- Intersection
-  Left:
-    - a
-      - String
-  Right:
-    - b
-      - Number
+        const expected = `- Intersection
+  Left:
+    - a
+      - String
+  Right:
+    - b
+      - Number
 `;
         expect((0, index_1.zodSchemaToMarkdown)(schema)).toBe(expected);
     });
     it('should convert ZodRecord to markdown', () => {
         const schema = zod_1.z.record(zod_1.z.string(), zod_1.z.number());
-        const expected = `- Record
-  Key:
-    - String
-  Value:
-    - Number
+        const expected = `- Record
+  Key:
+    - String
+  Value:
+    - Number
 `;
         expect((0, index_1.zodSchemaToMarkdown)(schema)).toBe(expected);
     });
     it('should convert ZodTuple to markdown', () => {
         const schema = zod_1.z.tuple([zod_1.z.string(), zod_1.z.number()]);
-        const expected = `- Tuple
-  [0]:
-    - String
-  [1]:
-    - Number
+        const expected = `- Tuple
+  [0]:
+    - String
+  [1]:
+    - Number
 `;
         expect((0, index_1.zodSchemaToMarkdown)(schema)).toBe(expected);
     });
     it('should convert ZodLiteral to markdown', () => {
         const schema = zod_1.z.literal('hello');
-        const expected = `- Literal: "hello"
+        const expected = `- Literal: "hello"
 `;
         expect((0, index_1.zodSchemaToMarkdown)(schema)).toBe(expected);
     });
     it('should convert ZodBigInt to markdown', () => {
         const schema = zod_1.z.bigint();
-        const expected = `- BigInt
+        const expected = `- BigInt
 `;
         expect((0, index_1.zodSchemaToMarkdown)(schema)).toBe(expected);
     });
     it('should convert ZodDate to markdown', () => {
         const schema = zod_1.z.date();
-        const expected = `- Date
+        const expected = `- Date
 `;
         expect((0, index_1.zodSchemaToMarkdown)(schema)).toBe(expected);
     });
     it('should convert ZodNaN to markdown', () => {
         const schema = zod_1.z.nan();
-        const expected = `- NaN
+        const expected = `- NaN
 `;
         expect((0, index_1.zodSchemaToMarkdown)(schema)).toBe(expected);
     });
     it('should convert ZodNever to markdown', () => {
         const schema = zod_1.z.never();
-        const expected = `- Never
+        const expected = `- Never
 `;
         expect((0, index_1.zodSchemaToMarkdown)(schema)).toBe(expected);
     });
     it('should convert ZodUnknown to markdown', () => {
         const schema = zod_1.z.unknown();
-        const expected = `- Unknown
+        const expected = `- Unknown
 `;
         expect((0, index_1.zodSchemaToMarkdown)(schema)).toBe(expected);
     });
     it('should convert ZodVoid to markdown', () => {
         const schema = zod_1.z.void();
-        const expected = `- Void
+        const expected = `- Void
 `;
         expect((0, index_1.zodSchemaToMarkdown)(schema)).toBe(expected);
     });
@@ -137,10 +137,10 @@ describe('zodSchemaToTable', () => {
             name: zod_1.z.string(),
             age: zod_1.z.number(),
         });
-        const expected = `| 字段 | 类型 | 描述 |
-|------|------|------|
-| name | String | - |
-| age | Number | - |
+        const expected = `| 字段 | 类型 | 描述 |
+|------|------|------|
+| name | String | - |
+| age | Number | - |
 `;
         expect((0, index_1.zodSchemaToTable)(schema)).toBe(expected);
     });
@@ -149,10 +149,10 @@ describe('zodSchemaToTable', () => {
             name: zod_1.z.string().optional(),
             email: zod_1.z.string().nullable(),
         });
-        const expected = `| 字段 | 类型 | 描述 |
-|------|------|------|
-| name | Optional<String> | - |
-| email | Nullable<String> | - |
+        const expected = `| 字段 | 类型 | 描述 |
+|------|------|------|
+| name | Optional<String> | - |
+| email | Nullable<String> | - |
 `;
         expect((0, index_1.zodSchemaToTable)(schema)).toBe(expected);
     });
@@ -160,9 +160,9 @@ describe('zodSchemaToTable', () => {
         const schema = zod_1.z.object({
             role: zod_1.z.enum(['admin', 'user', 'guest']),
         });
-        const expected = `| 字段 | 类型 | 描述 |
-|------|------|------|
-| role | Enum(admin | user | guest) | - |
+        const expected = `| 字段 | 类型 | 描述 |
+|------|------|------|
+| role | Enum(admin | user | guest) | - |
 `;
         expect((0, index_1.zodSchemaToTable)(schema)).toBe(expected);
     });
@@ -171,10 +171,10 @@ describe('zodSchemaToTable', () => {
             tags: zod_1.z.array(zod_1.z.string()),
             scores: zod_1.z.array(zod_1.z.number()),
         });
-        const expected = `| 字段 | 类型 | 描述 |
-|------|------|------|
-| tags[] | Array<String> | - |
-| scores[] | Array<Number> | - |
+        const expected = `| 字段 | 类型 | 描述 |
+|------|------|------|
+| tags[] | Array<String> | - |
+| scores[] | Array<Number> | - |
 `;
         expect((0, index_1.zodSchemaToTable)(schema)).toBe(expected);
     });
@@ -183,10 +183,10 @@ describe('zodSchemaToTable', () => {
             name: zod_1.z.string().describe('用户名称'),
             age: zod_1.z.number().describe('用户年龄'),
         });
-        const expected = `| 字段 | 类型 | 描述 |
-|------|------|------|
-| name | String | 用户名称 |
-| age | Number | 用户年龄 |
+        const expected = `| 字段 | 类型 | 描述 |
+|------|------|------|
+| name | String | 用户名称 |
+| age | Number | 用户年龄 |
 `;
         expect((0, index_1.zodSchemaToTable)(schema)).toBe(expected);
     });
@@ -195,16 +195,120 @@ describe('zodSchemaToTable', () => {
             status: zod_1.z.literal('active'),
             count: zod_1.z.literal(1),
         });
-        const expected = `| 字段 | 类型 | 描述 |
-|------|------|------|
-| status | Literal("active") | - |
-| count | Literal(1) | - |
+        const expected = `| 字段 | 类型 | 描述 |
+|------|------|------|
+| status | Literal("active") | - |
+| count | Literal(1) | - |
 `;
         expect((0, index_1.zodSchemaToTable)(schema)).toBe(expected);
     });
     it('should fallback to markdown for non-object schema', () => {
         const schema = zod_1.z.string();
-        const expected = `- String
+        const expected = `- String
+`;
+        expect((0, index_1.zodSchemaToTable)(schema)).toBe(expected);
+    });
+    it('should convert object schema with union to table', () => {
+        const schema = zod_1.z.object({
+            type: zod_1.z.union([zod_1.z.string(), zod_1.z.number()]),
+        });
+        const expected = `| 字段 | 类型 | 描述 |
+|------|------|------|
+| type (option 1) | String | - |
+| type (option 2) | Number | - |
+`;
+        expect((0, index_1.zodSchemaToTable)(schema)).toBe(expected);
+    });
+    it('should convert object schema with union of objects to table', () => {
+        const schema = zod_1.z.object({
+            data: zod_1.z.union([
+                zod_1.z.object({ name: zod_1.z.string() }),
+                zod_1.z.object({ age: zod_1.z.number() }),
+            ]),
+        });
+        const expected = `| 字段 | 类型 | 描述 |
+|------|------|------|
+| data (option 1): name | String | - |
+| data (option 2): age | Number | - |
+`;
+        expect((0, index_1.zodSchemaToTable)(schema)).toBe(expected);
+    });
+    it('should convert object schema with discriminated union to table', () => {
+        const schema = zod_1.z.object({
+            message: zod_1.z.discriminatedUnion('role', [
+                zod_1.z.object({ role: zod_1.z.literal('user'), name: zod_1.z.string() }),
+                zod_1.z.object({ role: zod_1.z.literal('admin'), level: zod_1.z.number() }),
+            ]),
+        });
+        const expected = `| 字段 | 类型 | 描述 |
+|------|------|------|
+| message (option 1): role | Literal("user") | - |
+| message (option 1): name | String | - |
+| message (option 2): role | Literal("admin") | - |
+| message (option 2): level | Number | - |
+`;
+        expect((0, index_1.zodSchemaToTable)(schema)).toBe(expected);
+    });
+    it('should convert object schema with intersection to table', () => {
+        const schema = zod_1.z.object({
+            merged: zod_1.z.object({ a: zod_1.z.string() }).and(zod_1.z.object({ b: zod_1.z.number() })),
+        });
+        const expected = `| 字段 | 类型 | 描述 |
+|------|------|------|
+| merged: a (Left) | String | - |
+| merged: b (Right) | Number | - |
+`;
+        expect((0, index_1.zodSchemaToTable)(schema)).toBe(expected);
+    });
+    it('should convert object schema with optional of union to table', () => {
+        const schema = zod_1.z.object({
+            value: zod_1.z.string().optional(),
+            data: zod_1.z.union([zod_1.z.string(), zod_1.z.number()]).optional(),
+        });
+        const expected = `| 字段 | 类型 | 描述 |
+|------|------|------|
+| value | Optional<String> | - |
+| data (option 1) | String | - |
+| data (option 2) | Number | - |
+`;
+        expect((0, index_1.zodSchemaToTable)(schema)).toBe(expected);
+    });
+    it('should convert object schema with array of union to table', () => {
+        const schema = zod_1.z.object({
+            items: zod_1.z.array(zod_1.z.union([zod_1.z.string(), zod_1.z.number()])),
+        });
+        const expected = `| 字段 | 类型 | 描述 |
+|------|------|------|
+| items[] (option 1) | String | - |
+| items[] (option 2) | Number | - |
+`;
+        expect((0, index_1.zodSchemaToTable)(schema)).toBe(expected);
+    });
+    it('should convert union with optional object to table', () => {
+        const schema = zod_1.z.object({
+            data: zod_1.z.union([
+                zod_1.z.object({ name: zod_1.z.string() }).optional(),
+                zod_1.z.object({ age: zod_1.z.number() }),
+            ]),
+        });
+        const expected = `| 字段 | 类型 | 描述 |
+|------|------|------|
+| data (option 1): name | Optional<String> | - |
+| data (option 2): age | Number | - |
+`;
+        expect((0, index_1.zodSchemaToTable)(schema)).toBe(expected);
+    });
+    it('should convert array of union with objects to table', () => {
+        const schema = zod_1.z.object({
+            items: zod_1.z.array(zod_1.z.union([
+                zod_1.z.object({ a: zod_1.z.string() }),
+                zod_1.z.object({ b: zod_1.z.number() }),
+            ])),
+        });
+        const expected = `| 字段 | 类型 | 描述 |
+|------|------|------|
+| items[].a (option 1) | String | - |
+| items[].b (option 2) | Number | - |
 `;
         expect((0, index_1.zodSchemaToTable)(schema)).toBe(expected);
     });