@ftschopp/dynatable-core 1.0.0

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

@@ -0,0 +1,232 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { applyPostDefaults } from './model-utils';
+import { ModelDefinition } from '../core/types';
+
+describe('applyPostDefaults - Timestamps', () => {
+  const testModel: ModelDefinition = {
+    key: {
+      PK: { type: String, value: 'USER#${username}' },
+      SK: { type: String, value: 'USER#${username}' },
+    },
+    attributes: {
+      username: { type: String, required: true },
+      name: { type: String },
+      email: { type: String },
+    },
+  };
+
+  beforeEach(() => {
+    jest.useFakeTimers();
+    jest.setSystemTime(new Date('2024-01-15T10:00:00.000Z'));
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  describe('Timestamps disabled (default)', () => {
+    test('should not add timestamps when disabled', () => {
+      const input = { username: 'alice', name: 'Alice' };
+      const result = applyPostDefaults(testModel, input, { timestamps: false });
+
+      expect(result.createdAt).toBeUndefined();
+      expect(result.updatedAt).toBeUndefined();
+    });
+
+    test('should not add timestamps when option not provided', () => {
+      const input = { username: 'alice', name: 'Alice' };
+      const result = applyPostDefaults(testModel, input);
+
+      expect(result.createdAt).toBeUndefined();
+      expect(result.updatedAt).toBeUndefined();
+    });
+  });
+
+  describe('Timestamps enabled for new items', () => {
+    test('should add createdAt and updatedAt for new items', () => {
+      const input = { username: 'alice', name: 'Alice' };
+      const result = applyPostDefaults(testModel, input, {
+        timestamps: true,
+        isUpdate: false,
+      });
+
+      expect(result.createdAt).toEqual('2024-01-15T10:00:00.000Z');
+      expect(result.updatedAt).toEqual('2024-01-15T10:00:00.000Z');
+    });
+
+    test('should not override existing createdAt', () => {
+      const existingCreatedAt = new Date('2024-01-01T00:00:00.000Z');
+      const input = {
+        username: 'alice',
+        name: 'Alice',
+        createdAt: existingCreatedAt,
+      };
+      const result = applyPostDefaults(testModel, input, {
+        timestamps: true,
+        isUpdate: false,
+      });
+
+      expect(result.createdAt).toEqual(existingCreatedAt);
+      expect(result.updatedAt).toEqual('2024-01-15T10:00:00.000Z');
+    });
+
+    test('should work with other defaults', () => {
+      const modelWithDefaults: ModelDefinition = {
+        key: {
+          PK: { type: String, value: 'USER#${username}' },
+          SK: { type: String, value: 'USER#${username}' },
+        },
+        attributes: {
+          username: { type: String, required: true },
+          name: { type: String },
+          status: { type: String, default: 'active' },
+          score: { type: Number, default: 0 },
+        },
+      };
+
+      const input = { username: 'alice', name: 'Alice' };
+      const result = applyPostDefaults(modelWithDefaults, input, {
+        timestamps: true,
+        isUpdate: false,
+      });
+
+      expect(result.status).toBe('active');
+      expect(result.score).toBe(0);
+      expect(result.createdAt).toEqual('2024-01-15T10:00:00.000Z');
+      expect(result.updatedAt).toEqual('2024-01-15T10:00:00.000Z');
+    });
+  });
+
+  describe('Timestamps enabled for updates', () => {
+    test('should only add updatedAt for updates', () => {
+      const input = { username: 'alice', name: 'Alice Updated' };
+      const result = applyPostDefaults(testModel, input, {
+        timestamps: true,
+        isUpdate: true,
+      });
+
+      expect(result.createdAt).toBeUndefined();
+      expect(result.updatedAt).toEqual('2024-01-15T10:00:00.000Z');
+    });
+
+    test('should update updatedAt even if already present', () => {
+      const oldUpdatedAt = new Date('2024-01-01T00:00:00.000Z');
+      const input = {
+        username: 'alice',
+        name: 'Alice Updated',
+        updatedAt: oldUpdatedAt,
+      };
+      const result = applyPostDefaults(testModel, input, {
+        timestamps: true,
+        isUpdate: true,
+      });
+
+      expect(result.updatedAt).toEqual('2024-01-15T10:00:00.000Z');
+      expect(result.updatedAt).not.toEqual(oldUpdatedAt);
+    });
+
+    test('should preserve existing createdAt on update', () => {
+      const existingCreatedAt = new Date('2024-01-01T00:00:00.000Z');
+      const input = {
+        username: 'alice',
+        name: 'Alice Updated',
+        createdAt: existingCreatedAt,
+      };
+      const result = applyPostDefaults(testModel, input, {
+        timestamps: true,
+        isUpdate: true,
+      });
+
+      expect(result.createdAt).toEqual(existingCreatedAt);
+      expect(result.updatedAt).toEqual('2024-01-15T10:00:00.000Z');
+    });
+  });
+
+  describe('Generated values with timestamps', () => {
+    test('should work with ULID generation', () => {
+      const modelWithUlid: ModelDefinition = {
+        key: {
+          PK: { type: String, value: 'USER#${id}' },
+          SK: { type: String, value: 'USER#${id}' },
+        },
+        attributes: {
+          id: { type: String, generate: 'ulid' },
+          username: { type: String, required: true },
+        },
+      };
+
+      const input = { username: 'alice' };
+      const result = applyPostDefaults(modelWithUlid, input, {
+        timestamps: true,
+        isUpdate: false,
+      });
+
+      expect(result.id).toBeDefined();
+      expect(typeof result.id).toBe('string');
+      expect(result.id.length).toBeGreaterThan(0);
+      expect(result.createdAt).toEqual('2024-01-15T10:00:00.000Z');
+      expect(result.updatedAt).toEqual('2024-01-15T10:00:00.000Z');
+    });
+
+    test('should work with UUID generation', () => {
+      const modelWithUuid: ModelDefinition = {
+        key: {
+          PK: { type: String, value: 'USER#${id}' },
+          SK: { type: String, value: 'USER#${id}' },
+        },
+        attributes: {
+          id: { type: String, generate: 'uuid' },
+          username: { type: String, required: true },
+        },
+      };
+
+      const input = { username: 'alice' };
+      const result = applyPostDefaults(modelWithUuid, input, {
+        timestamps: true,
+        isUpdate: false,
+      });
+
+      expect(result.id).toBeDefined();
+      expect(typeof result.id).toBe('string');
+      expect(result.id).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/);
+      expect(result.createdAt).toEqual('2024-01-15T10:00:00.000Z');
+      expect(result.updatedAt).toEqual('2024-01-15T10:00:00.000Z');
+    });
+  });
+
+  describe('Edge cases', () => {
+    test('should handle empty input', () => {
+      const input = {};
+      const result = applyPostDefaults(testModel, input, {
+        timestamps: true,
+        isUpdate: false,
+      });
+
+      expect(result.createdAt).toEqual('2024-01-15T10:00:00.000Z');
+      expect(result.updatedAt).toEqual('2024-01-15T10:00:00.000Z');
+    });
+
+    test('should handle multiple consecutive calls with different times', () => {
+      const input1 = { username: 'alice' };
+      const input2 = { username: 'bob' };
+
+      jest.setSystemTime(new Date('2024-01-15T10:00:00.000Z'));
+      const result1 = applyPostDefaults(testModel, input1, {
+        timestamps: true,
+        isUpdate: false,
+      });
+
+      jest.setSystemTime(new Date('2024-01-15T11:00:00.000Z'));
+      const result2 = applyPostDefaults(testModel, input2, {
+        timestamps: true,
+        isUpdate: false,
+      });
+
+      expect(result1.createdAt).toEqual('2024-01-15T10:00:00.000Z');
+      expect(result1.updatedAt).toEqual('2024-01-15T10:00:00.000Z');
+
+      expect(result2.createdAt).toEqual('2024-01-15T11:00:00.000Z');
+      expect(result2.updatedAt).toEqual('2024-01-15T11:00:00.000Z');
+    });
+  });
+});

package/src/utils/model-utils.ts

@@ -0,0 +1,101 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { InferModel, KeyDefinition, ModelDefinition } from '@/core/types';
+import { ulid } from 'ulid';
+
+/**
+ * Extracts all variable names from a template string
+ * @param template - Template string with ${variable} syntax
+ * @returns Array of variable names found in the template
+ */
+export const extractTemplateVars = (template: string): string[] => {
+  const matches = template.matchAll(/\${(.*?)}/g);
+  return Array.from(matches, (m) => m[1]).filter((v): v is string => v !== undefined);
+};
+
+/**
+ * Resolves a string template with provided data
+ * @throws Error if any required template variable is missing from data
+ */
+export const resolveTemplate = (template: string, data: Record<string, any>): string => {
+  const missing: string[] = [];
+
+  const result = template.replace(/\${(.*?)}/g, (_, key) => {
+    const value = data[key];
+    if (value === undefined) {
+      missing.push(key);
+      return `\${${key}}`; // Keep placeholder for error message
+    }
+    return String(value);
+  });
+
+  if (missing.length > 0) {
+    throw new Error(
+      `Missing required field(s) for key template: ${missing.join(', ')}. ` +
+        `Template: "${template}"`
+    );
+  }
+
+  return result;
+};
+
+/**
+ * Resolves all keys or indexes for a model
+ */
+export const resolveKeys = <M extends ModelDefinition>(
+  model: M,
+  input: Record<string, any>,
+  type: 'key' | 'index' | 'both' = 'key'
+): Record<string, string> => {
+  const out: Record<string, string> = {};
+  const process = (keys?: Record<string, KeyDefinition>) => {
+    if (!keys) return;
+    for (const [k, def] of Object.entries(keys)) {
+      out[k] = resolveTemplate(def.value, input);
+    }
+  };
+  if (type === 'key' || type === 'both') process(model.key);
+  if (type === 'index' || type === 'both') process(model.index);
+  return out;
+};
+
+/**
+ * Applies default and generated values to validated input
+ */
+export const applyPostDefaults = <M extends ModelDefinition>(
+  model: M,
+  validatedItem: Record<string, any>,
+  options?: { isUpdate?: boolean; timestamps?: boolean }
+): InferModel<M> => {
+  const result: Record<string, any> = { ...validatedItem };
+
+  for (const [key, attr] of Object.entries(model.attributes)) {
+    if (result[key] === undefined) {
+      if (attr.generate === 'ulid') {
+        result[key] = ulid();
+      } else if (attr.generate === 'uuid') {
+        result[key] = crypto.randomUUID();
+      } else if (attr.default !== undefined) {
+        result[key] = typeof attr.default === 'function' ? attr.default() : attr.default;
+      }
+    }
+  }
+
+  // Apply timestamps if enabled
+  const enableTimestamps = options?.timestamps ?? false;
+  const isUpdate = options?.isUpdate ?? false;
+
+  if (enableTimestamps) {
+    const now = new Date().toISOString();
+
+    // Only set createdAt on new items (not updates)
+    if (!isUpdate && result.createdAt === undefined) {
+      result.createdAt = now;
+    }
+
+    // Always set updatedAt
+    result.updatedAt = now;
+  }
+
+  return result as InferModel<M>;
+};

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

@@ -0,0 +1,272 @@
+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 unknown types', () => {
+      const attr: AttributeDefinition = {
+        type: Array 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();
+    });
+  });
+
+  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

@@ -0,0 +1,36 @@
+/* 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
+ */
+export const typeToZod = (attr: AttributeDefinition): ZodType => {
+  const zodType: ZodType =
+    attr.type === String
+      ? z.string()
+      : attr.type === Number
+        ? z.number()
+        : attr.type === Boolean
+          ? z.boolean()
+          : attr.type === Date
+            ? z.date()
+            : z.unknown();
+
+  return attr.required ? 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.object(shape).passthrough();
+};