@ftschopp/dynatable-core 1.4.2 → 1.4.3

package/src/utils/zod-utils.test.ts

@@ -1,363 +0,0 @@
-import { modelToZod, typeToZod } from './zod-utils';
-import type { AttributeDefinition, ModelDefinition } from '../core/types';
-
-describe('zod-utils', () => {
-  describe('typeToZod', () => {
-    it('should convert String type to z.string()', () => {
-      const attr: AttributeDefinition = {
-        type: String,
-        required: true,
-      };
-      const zodType = typeToZod(attr);
-
-      expect(() => zodType.parse('hello')).not.toThrow();
-      expect(() => zodType.parse(123)).toThrow();
-    });
-
-    it('should convert Number type to z.number()', () => {
-      const attr: AttributeDefinition = {
-        type: Number,
-        required: true,
-      };
-      const zodType = typeToZod(attr);
-
-      expect(() => zodType.parse(42)).not.toThrow();
-      expect(() => zodType.parse('42')).toThrow();
-    });
-
-    it('should convert Boolean type to z.boolean()', () => {
-      const attr: AttributeDefinition = {
-        type: Boolean,
-        required: true,
-      };
-      const zodType = typeToZod(attr);
-
-      expect(() => zodType.parse(true)).not.toThrow();
-      expect(() => zodType.parse(false)).not.toThrow();
-      expect(() => zodType.parse('true')).toThrow();
-    });
-
-    it('should convert Date type to z.date()', () => {
-      const attr: AttributeDefinition = {
-        type: Date,
-        required: true,
-      };
-      const zodType = typeToZod(attr);
-
-      const now = new Date();
-      expect(() => zodType.parse(now)).not.toThrow();
-      expect(() => zodType.parse('2024-01-01')).toThrow();
-    });
-
-    it('should make optional fields when required is false', () => {
-      const attr: AttributeDefinition = {
-        type: String,
-        required: false,
-      };
-      const zodType = typeToZod(attr);
-
-      expect(() => zodType.parse('hello')).not.toThrow();
-      expect(() => zodType.parse(undefined)).not.toThrow();
-    });
-
-    it('should make required fields when required is true', () => {
-      const attr: AttributeDefinition = {
-        type: String,
-        required: true,
-      };
-      const zodType = typeToZod(attr);
-
-      expect(() => zodType.parse('hello')).not.toThrow();
-      expect(() => zodType.parse(undefined)).toThrow();
-    });
-
-    it('should return z.unknown() for unrecognized types', () => {
-      const attr: AttributeDefinition = {
-        type: Map as any,
-        required: true,
-      };
-      const zodType = typeToZod(attr);
-
-      // z.unknown() accepts any value
-      expect(() => zodType.parse('anything')).not.toThrow();
-      expect(() => zodType.parse(123)).not.toThrow();
-      expect(() => zodType.parse([])).not.toThrow();
-    });
-
-    it('should convert Object type with schema to z.looseObject()', () => {
-      const attr: AttributeDefinition = {
-        type: Object,
-        schema: {
-          city: { type: String, required: true },
-          zip: { type: String },
-        },
-        required: true,
-      };
-      const zodType = typeToZod(attr);
-
-      expect(() => zodType.parse({ city: 'BA' })).not.toThrow();
-      expect(() => zodType.parse({ city: 'BA', zip: '1000' })).not.toThrow();
-      expect(() => zodType.parse({ zip: '1000' })).toThrow(); // city required
-      expect(() => zodType.parse({})).toThrow();
-    });
-
-    it('should convert Object type without schema to z.record()', () => {
-      const attr: AttributeDefinition = {
-        type: Object,
-        schema: {},
-      };
-      const zodType = typeToZod(attr);
-      expect(() => zodType.parse({})).not.toThrow();
-    });
-
-    it('should convert Array type with scalar items', () => {
-      const attr: AttributeDefinition = {
-        type: Array,
-        items: { type: String },
-        required: true,
-      };
-      const zodType = typeToZod(attr);
-
-      expect(() => zodType.parse(['a', 'b'])).not.toThrow();
-      expect(() => zodType.parse([])).not.toThrow();
-      expect(() => zodType.parse([1, 2])).toThrow(); // numbers, not strings
-    });
-
-    it('should convert Array type with object items (like history)', () => {
-      const attr: AttributeDefinition = {
-        type: Array,
-        items: {
-          type: Object,
-          schema: {
-            date: { type: String },
-            status: { type: String, required: true },
-          },
-        },
-        required: true,
-      };
-      const zodType = typeToZod(attr);
-
-      expect(() => zodType.parse([{ status: 'PENDING' }])).not.toThrow();
-      expect(() => zodType.parse([{ date: '2024-01-01', status: 'DONE' }])).not.toThrow();
-      expect(() => zodType.parse([{ date: '2024-01-01' }])).toThrow(); // missing status
-    });
-
-    it('should handle optional Object attribute', () => {
-      const attr: AttributeDefinition = {
-        type: Object,
-        schema: { name: { type: String, required: true } },
-      };
-      const zodType = typeToZod(attr);
-
-      expect(() => zodType.parse(undefined)).not.toThrow();
-      expect(() => zodType.parse({ name: 'test' })).not.toThrow();
-    });
-
-    it('should handle deeply nested objects', () => {
-      const attr: AttributeDefinition = {
-        type: Object,
-        required: true,
-        schema: {
-          value: { type: Number, required: true },
-          breakdown: {
-            type: Object,
-            schema: {
-              base: { type: Number, required: true },
-              fees: { type: Number, required: true },
-            },
-          },
-        },
-      };
-      const zodType = typeToZod(attr);
-
-      expect(() => zodType.parse({ value: 100, breakdown: { base: 90, fees: 10 } })).not.toThrow();
-      expect(() => zodType.parse({ value: 100 })).not.toThrow(); // breakdown optional
-      expect(() => zodType.parse({})).toThrow(); // value required
-    });
-  });
-
-  describe('modelToZod', () => {
-    it('should convert a simple model to Zod schema', () => {
-      const model: ModelDefinition = {
-        key: {
-          PK: { type: String, value: 'USER#${id}' },
-          SK: { type: String, value: 'PROFILE' },
-        },
-        attributes: {
-          id: { type: String, required: true },
-          name: { type: String, required: true },
-          age: { type: Number, required: false },
-        },
-      };
-
-      const zodSchema = modelToZod(model);
-
-      const validData = {
-        id: 'user-123',
-        name: 'John Doe',
-        age: 30,
-      };
-
-      expect(() => zodSchema.parse(validData)).not.toThrow();
-    });
-
-    it('should allow optional fields to be missing', () => {
-      const model: ModelDefinition = {
-        key: {
-          PK: { type: String, value: 'USER#${id}' },
-          SK: { type: String, value: 'PROFILE' },
-        },
-        attributes: {
-          id: { type: String, required: true },
-          email: { type: String, required: false },
-        },
-      };
-
-      const zodSchema = modelToZod(model);
-
-      const dataWithoutOptional = {
-        id: 'user-123',
-      };
-
-      expect(() => zodSchema.parse(dataWithoutOptional)).not.toThrow();
-    });
-
-    it('should reject missing required fields', () => {
-      const model: ModelDefinition = {
-        key: {
-          PK: { type: String, value: 'USER#${id}' },
-          SK: { type: String, value: 'PROFILE' },
-        },
-        attributes: {
-          id: { type: String, required: true },
-          name: { type: String, required: true },
-        },
-      };
-
-      const zodSchema = modelToZod(model);
-
-      const invalidData = {
-        id: 'user-123',
-        // name is missing
-      };
-
-      expect(() => zodSchema.parse(invalidData)).toThrow();
-    });
-
-    it('should use passthrough to allow additional fields', () => {
-      const model: ModelDefinition = {
-        key: {
-          PK: { type: String, value: 'USER#${id}' },
-          SK: { type: String, value: 'PROFILE' },
-        },
-        attributes: {
-          id: { type: String, required: true },
-        },
-      };
-
-      const zodSchema = modelToZod(model);
-
-      const dataWithExtraFields = {
-        id: 'user-123',
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        someOtherField: 'value',
-      };
-
-      // Should not throw because of passthrough mode
-      expect(() => zodSchema.parse(dataWithExtraFields)).not.toThrow();
-    });
-
-    it('should handle complex models with multiple types', () => {
-      const model: ModelDefinition = {
-        key: {
-          PK: { type: String, value: 'PRODUCT#${id}' },
-          SK: { type: String, value: 'DETAILS' },
-        },
-        attributes: {
-          id: { type: String, required: true },
-          name: { type: String, required: true },
-          price: { type: Number, required: true },
-          available: { type: Boolean, required: false },
-          releaseDate: { type: Date, required: false },
-        },
-      };
-
-      const zodSchema = modelToZod(model);
-
-      const validProduct = {
-        id: 'prod-123',
-        name: 'Laptop',
-        price: 999.99,
-        available: true,
-        releaseDate: new Date('2024-01-01'),
-      };
-
-      expect(() => zodSchema.parse(validProduct)).not.toThrow();
-    });
-
-    it('should reject wrong types', () => {
-      const model: ModelDefinition = {
-        key: {
-          PK: { type: String, value: 'USER#${id}' },
-          SK: { type: String, value: 'PROFILE' },
-        },
-        attributes: {
-          id: { type: String, required: true },
-          age: { type: Number, required: true },
-        },
-      };
-
-      const zodSchema = modelToZod(model);
-
-      const invalidData = {
-        id: 'user-123',
-        age: '30', // Wrong type: string instead of number
-      };
-
-      expect(() => zodSchema.parse(invalidData)).toThrow();
-    });
-
-    it('should handle empty models', () => {
-      const model: ModelDefinition = {
-        key: {
-          PK: { type: String, value: 'EMPTY#${id}' },
-          SK: { type: String, value: 'ITEM' },
-        },
-        attributes: {},
-      };
-
-      const zodSchema = modelToZod(model);
-
-      expect(() => zodSchema.parse({})).not.toThrow();
-      // Passthrough allows any fields
-      expect(() => zodSchema.parse({ anyField: 'value' })).not.toThrow();
-    });
-
-    it('should validate parsed data correctly', () => {
-      const model: ModelDefinition = {
-        key: {
-          PK: { type: String, value: 'USER#${id}' },
-          SK: { type: String, value: 'PROFILE' },
-        },
-        attributes: {
-          id: { type: String, required: true },
-          count: { type: Number, required: true },
-        },
-      };
-
-      const zodSchema = modelToZod(model);
-
-      const data = {
-        id: 'user-123',
-        count: 42,
-        extra: 'allowed',
-      };
-
-      const parsed = zodSchema.parse(data);
-      expect(parsed.id).toBe('user-123');
-      expect(parsed.count).toBe(42);
-      expect(parsed.extra).toBe('allowed');
-    });
-  });
-});

package/src/utils/zod-utils.ts

@@ -1,56 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-// -------------------- Zod Conversion --------------------
-
-import { AttributeDefinition, ModelDefinition } from '@/core/types';
-import { z, ZodObject, ZodType } from 'zod';
-
-/**
- * Converts an attribute definition to a Zod schema type.
- * Supports scalars, nested objects (with schema), and arrays (with items).
- */
-export const typeToZod = (attr: AttributeDefinition): ZodType => {
-  let zodType: ZodType;
-
-  if (attr.type === Object) {
-    const schema = (attr as { schema?: Record<string, AttributeDefinition> }).schema;
-    if (schema) {
-      const shape: Record<string, ZodType> = {};
-      for (const [key, nestedAttr] of Object.entries(schema)) {
-        shape[key] = typeToZod(nestedAttr);
-      }
-      zodType = z.looseObject(shape);
-    } else {
-      zodType = z.record(z.string(), z.unknown());
-    }
-  } else if (attr.type === Array) {
-    const items = (attr as { items?: AttributeDefinition }).items;
-    zodType = items ? z.array(typeToZod(items)) : z.array(z.unknown());
-  } else {
-    zodType =
-      attr.type === String
-        ? z.string()
-        : attr.type === Number
-          ? z.number()
-          : attr.type === Boolean
-            ? z.boolean()
-            : attr.type === Date
-              ? z.date()
-              : z.unknown();
-  }
-
-  const isGenerated = 'generate' in attr;
-  return attr.required && !isGenerated ? zodType : zodType.optional();
-};
-
-/**
- * Converts a model definition to a Zod object schema
- * Uses passthrough mode to allow additional fields like createdAt/updatedAt
- * that are added by applyPostDefaults when timestamps are enabled
- */
-export const modelToZod = (model: ModelDefinition): ZodObject<any> => {
-  const shape: Record<string, ZodType> = {};
-  for (const [key, attr] of Object.entries(model.attributes)) {
-    shape[key] = typeToZod(attr);
-  }
-  return z.looseObject(shape);
-};