@ftschopp/dynatable-core 1.4.2 → 1.4.4

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

@@ -1,452 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { applyPostDefaults, computeIndexUpdates, stripInternalKeys } 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');
-    });
-  });
-});
-
-describe('stripInternalKeys', () => {
-  test('should remove PK, SK, and _type from object', () => {
-    const input = {
-      PK: 'USER#alice',
-      SK: 'USER#alice',
-      _type: 'User',
-      username: 'alice',
-      name: 'Alice',
-      email: 'alice@example.com',
-    };
-
-    const result = stripInternalKeys(input);
-
-    expect(result).toEqual({
-      username: 'alice',
-      name: 'Alice',
-      email: 'alice@example.com',
-    });
-  });
-
-  test('should handle object without internal keys', () => {
-    const input = {
-      username: 'alice',
-      name: 'Alice',
-      email: 'alice@example.com',
-    };
-
-    const result = stripInternalKeys(input);
-
-    expect(result).toEqual(input);
-  });
-
-  test('should handle array of objects', () => {
-    const input = [
-      {
-        PK: 'USER#alice',
-        SK: 'USER#alice',
-        _type: 'User',
-        username: 'alice',
-        name: 'Alice',
-      },
-      {
-        PK: 'USER#bob',
-        SK: 'USER#bob',
-        _type: 'User',
-        username: 'bob',
-        name: 'Bob',
-      },
-    ];
-
-    const result = stripInternalKeys(input);
-
-    expect(result).toEqual([
-      { username: 'alice', name: 'Alice' },
-      { username: 'bob', name: 'Bob' },
-    ]);
-  });
-
-  test('should handle undefined', () => {
-    const result = stripInternalKeys(undefined);
-    expect(result).toBeUndefined();
-  });
-
-  test('should handle null', () => {
-    const result = stripInternalKeys(null);
-    expect(result).toBeNull();
-  });
-
-  test('should handle empty object', () => {
-    const input = {};
-    const result = stripInternalKeys(input);
-    expect(result).toEqual({});
-  });
-
-  test('should handle empty array', () => {
-    const input: any[] = [];
-    const result = stripInternalKeys(input);
-    expect(result).toEqual([]);
-  });
-
-  test('should preserve other fields with similar names', () => {
-    const input = {
-      PK: 'USER#alice',
-      SK: 'USER#alice',
-      _type: 'User',
-      PKG: 'package-name',
-      SKIP: 'skip-value',
-      type: 'customer',
-      username: 'alice',
-    };
-
-    const result = stripInternalKeys(input);
-
-    expect(result).toEqual({
-      PKG: 'package-name',
-      SKIP: 'skip-value',
-      type: 'customer',
-      username: 'alice',
-    });
-  });
-
-  test('should handle nested objects (does not recurse)', () => {
-    const input = {
-      PK: 'USER#alice',
-      SK: 'USER#alice',
-      _type: 'User',
-      username: 'alice',
-      metadata: {
-        PK: 'METADATA#1',
-        SK: 'METADATA#1',
-        _type: 'Metadata',
-        value: 'test',
-      },
-    };
-
-    const result = stripInternalKeys(input);
-
-    // stripInternalKeys does not recurse into nested objects
-    expect(result).toEqual({
-      username: 'alice',
-      metadata: {
-        PK: 'METADATA#1',
-        SK: 'METADATA#1',
-        _type: 'Metadata',
-        value: 'test',
-      },
-    });
-  });
-});
-
-describe('computeIndexUpdates', () => {
-  const personnelModel: ModelDefinition = {
-    key: {
-      PK: { type: String, value: 'PERSON#${id}' },
-      SK: { type: String, value: 'PROFILE' },
-    },
-    index: {
-      GSI1PK: { type: String, value: 'AIRPORT#${airportId}' },
-      GSI1SK: { type: String, value: 'PERSON#${lastName}#${firstName}' },
-    },
-    attributes: {
-      id: { type: String, required: true },
-      airportId: { type: String, required: true },
-      firstName: { type: String, required: true },
-      lastName: { type: String, required: true },
-    },
-  };
-
-  test('returns empty result when model has no indexes', () => {
-    const noIndexModel: ModelDefinition = {
-      key: {
-        PK: { type: String, value: 'USER#${id}' },
-        SK: { type: String, value: 'USER#${id}' },
-      },
-      attributes: { id: { type: String, required: true } },
-    };
-    const result = computeIndexUpdates(noIndexModel, { id: '1' }, { name: 'X' });
-    expect(result).toEqual({ actions: {}, missing: [] });
-  });
-
-  test('skips indexes whose template references no updated field', () => {
-    // Updating only "role" — none of the index templates mention role.
-    const result = computeIndexUpdates(
-      personnelModel,
-      { id: '1' },
-      { role: 'pilot' }
-    );
-    expect(result).toEqual({ actions: {}, missing: [] });
-  });
-
-  test('recomputes an affected index when all template vars resolve', () => {
-    const result = computeIndexUpdates(
-      personnelModel,
-      { id: '1' },
-      { firstName: 'Ada', lastName: 'Lovelace' }
-    );
-    expect(result.actions).toEqual({ GSI1SK: 'PERSON#Lovelace#Ada' });
-    expect(result.missing).toEqual([]);
-  });
-
-  test('reports missing template vars instead of throwing', () => {
-    const result = computeIndexUpdates(
-      personnelModel,
-      { id: '1' },
-      { lastName: 'Lovelace' }
-    );
-    expect(result.actions).toEqual({});
-    expect(result.missing).toEqual([
-      {
-        index: 'GSI1SK',
-        template: 'PERSON#${lastName}#${firstName}',
-        missing: ['firstName'],
-      },
-    ]);
-  });
-
-  test('uses keyVars to resolve fields not present in updates', () => {
-    // airportId is not in updates but in keyVars — GSI1PK should still resolve.
-    const result = computeIndexUpdates(
-      personnelModel,
-      { id: '1', airportId: 'EZE' },
-      { airportId: 'AEP' } // changing it
-    );
-    expect(result.actions).toEqual({ GSI1PK: 'AIRPORT#AEP' });
-  });
-
-  test('handles multiple affected indexes independently', () => {
-    const result = computeIndexUpdates(
-      personnelModel,
-      { id: '1' },
-      { airportId: 'AEP', firstName: 'Ada', lastName: 'Lovelace' }
-    );
-    expect(result.actions).toEqual({
-      GSI1PK: 'AIRPORT#AEP',
-      GSI1SK: 'PERSON#Lovelace#Ada',
-    });
-    expect(result.missing).toEqual([]);
-  });
-});

package/src/utils/model-utils.ts

@@ -1,188 +0,0 @@
-/* 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;
-};
-
-/**
- * Result of analyzing how a partial update affects a model's secondary index keys.
- *
- * `actions` maps index-attribute name → freshly resolved template value, ready to SET.
- * `missing` lists indexes whose template references at least one updated field but
- * cannot be fully resolved from `keyVars + updates`; those entries identify the
- * variables the caller must additionally provide.
- */
-export type IndexUpdateAnalysis = {
-  actions: Record<string, string>;
-  missing: { index: string; template: string; missing: string[] }[];
-};
-
-/**
- * Determines which secondary-index keys must be recomputed given a partial update.
- *
- * An index is "affected" iff at least one of its template variables appears in
- * `updates`. For each affected index we attempt to resolve the template from the
- * union of `keyVars` (template vars carried in the primary key, e.g. `id`) and
- * `updates` (the user's `.set()` payload). If any template variable is missing
- * from that union, the index is reported in `missing` instead of `actions` —
- * recomputing it would require reading the existing item from DynamoDB, which
- * the builder intentionally does not do.
- */
-export const computeIndexUpdates = <M extends ModelDefinition>(
-  model: M,
-  keyVars: Record<string, any>,
-  updates: Record<string, any>
-): IndexUpdateAnalysis => {
-  const actions: Record<string, string> = {};
-  const missing: { index: string; template: string; missing: string[] }[] = [];
-
-  if (!model.index) return { actions, missing };
-
-  const updateKeys = new Set(Object.keys(updates));
-  const combined: Record<string, any> = { ...keyVars, ...updates };
-
-  for (const [indexName, indexDef] of Object.entries(model.index)) {
-    const templateVars = extractTemplateVars(indexDef.value);
-    const isAffected = templateVars.some((v) => updateKeys.has(v));
-    if (!isAffected) continue;
-
-    const missingVars = templateVars.filter((v) => combined[v] === undefined);
-    if (missingVars.length > 0) {
-      missing.push({ index: indexName, template: indexDef.value, missing: missingVars });
-      continue;
-    }
-
-    actions[indexName] = resolveTemplate(indexDef.value, combined);
-  }
-
-  return { actions, missing };
-};
-
-/**
- * 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) {
-      const generate = 'generate' in attr ? attr.generate : undefined;
-      if (generate === 'ulid') {
-        result[key] = ulid();
-      } else if (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>;
-};
-
-/**
- * Internal DynamoDB keys that should be stripped when cleanInternalKeys is enabled
- */
-const INTERNAL_KEYS = ['PK', 'SK', '_type'] as const;
-
-/**
- * Removes internal DynamoDB keys from an item or array of items
- * @param data - Single item or array of items from DynamoDB
- * @returns Data with internal keys removed
- */
-export const stripInternalKeys = <T>(data: T | T[] | undefined): T | T[] | undefined => {
-  if (data === undefined || data === null) {
-    return data;
-  }
-
-  if (Array.isArray(data)) {
-    return data.map((item) => stripInternalKeys(item)) as T[];
-  }
-
-  if (typeof data === 'object') {
-    const cleaned: any = {};
-    for (const [key, value] of Object.entries(data)) {
-      if (!INTERNAL_KEYS.includes(key as any)) {
-        cleaned[key] = value;
-      }
-    }
-    return cleaned as T;
-  }
-
-  return data;
-};