@ftschopp/dynatable-core 1.0.0 → 1.1.0

package/dist/entity.js

@@ -1,161 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createEntityAPI = void 0;
-const model_utils_1 = require("./utils/model-utils");
-const zod_utils_1 = require("./utils/zod-utils");
-const builders_1 = require("./builders");
-/**
- * Creates an entity API instance with validation, key resolution, and builder creation.
- *
- * @param modelName - The name of the model/entity
- * @param model - The model definition
- * @param client - DynamoDB client instance
- * @param options - Optional configuration (logger, timestamps)
- * @returns EntityAPI with get and put methods
- */
-const createEntityAPI = (tableName, modelName, model, client, options = {}) => {
-    const { logger, timestamps = false } = options;
-    // Build a Zod schema from the model
-    const zodSchema = (0, zod_utils_1.modelToZod)(model);
-    return {
-        get(key) {
-            // Extract required fields from key templates
-            const requiredFields = new Set();
-            if (model.key) {
-                for (const keyDef of Object.values(model.key)) {
-                    (0, model_utils_1.extractTemplateVars)(keyDef.value).forEach((field) => requiredFields.add(field));
-                }
-            }
-            // Check if all required fields are present
-            const keyRecord = key;
-            const missingFields = Array.from(requiredFields).filter((field) => keyRecord[field] === undefined);
-            if (missingFields.length > 0) {
-                throw new Error(`[${modelName}] Missing required key field(s) for get(): ${missingFields.join(', ')}. ` +
-                    `Required fields: ${Array.from(requiredFields).join(', ')}`);
-            }
-            // Resolve any key defaults or computed keys
-            const fullKey = (0, model_utils_1.resolveKeys)(model, key);
-            return (0, builders_1.createGetBuilder)(tableName, fullKey, client, undefined, logger);
-        },
-        put(item) {
-            // Validate full input data
-            const parsed = zodSchema.parse(item);
-            // Apply post-processing defaults from the model (including timestamps for new items)
-            const withDefaults = (0, model_utils_1.applyPostDefaults)(model, parsed, {
-                isUpdate: false,
-                timestamps,
-            });
-            // Resolve keys again with defaults
-            const fullKey = (0, model_utils_1.resolveKeys)(model, withDefaults);
-            // Combine keys and data into full item, adding _type field
-            const fullItem = {
-                ...withDefaults,
-                ...fullKey,
-                _type: modelName, // Add entity type identifier
-            };
-            return (0, builders_1.createPutBuilder)(tableName, fullItem, client, [], false, 'NONE', false, logger);
-        },
-        query() {
-            return (0, builders_1.createQueryBuilder)(tableName, client, model, logger);
-        },
-        scan() {
-            return (0, builders_1.createScanBuilder)(tableName, client, [], [], undefined, false, undefined, undefined, undefined, logger);
-        },
-        update(key) {
-            // Extract required fields from key templates
-            const requiredFields = new Set();
-            if (model.key) {
-                for (const keyDef of Object.values(model.key)) {
-                    (0, model_utils_1.extractTemplateVars)(keyDef.value).forEach((field) => requiredFields.add(field));
-                }
-            }
-            // Check if all required fields are present
-            const keyRecord = key;
-            const missingFields = Array.from(requiredFields).filter((field) => keyRecord[field] === undefined);
-            if (missingFields.length > 0) {
-                throw new Error(`[${modelName}] Missing required key field(s) for update(): ${missingFields.join(', ')}. ` +
-                    `Required fields: ${Array.from(requiredFields).join(', ')}`);
-            }
-            // Resolve any key defaults or computed keys
-            const fullKey = (0, model_utils_1.resolveKeys)(model, key);
-            return (0, builders_1.createUpdateBuilder)(tableName, fullKey, client, [], { set: [], remove: [], add: [], delete: [] }, 'NONE', 0, timestamps, logger);
-        },
-        delete(key) {
-            // Extract required fields from key templates
-            const requiredFields = new Set();
-            if (model.key) {
-                for (const keyDef of Object.values(model.key)) {
-                    (0, model_utils_1.extractTemplateVars)(keyDef.value).forEach((field) => requiredFields.add(field));
-                }
-            }
-            // Check if all required fields are present
-            const keyRecord = key;
-            const missingFields = Array.from(requiredFields).filter((field) => keyRecord[field] === undefined);
-            if (missingFields.length > 0) {
-                throw new Error(`[${modelName}] Missing required key field(s) for delete(): ${missingFields.join(', ')}. ` +
-                    `Required fields: ${Array.from(requiredFields).join(', ')}`);
-            }
-            // Resolve any key defaults or computed keys
-            const fullKey = (0, model_utils_1.resolveKeys)(model, key);
-            return (0, builders_1.createDeleteBuilder)(tableName, fullKey, client, [], 'NONE', logger);
-        },
-        batchGet(keys) {
-            // Extract required fields from key templates
-            const requiredFields = new Set();
-            if (model.key) {
-                for (const keyDef of Object.values(model.key)) {
-                    (0, model_utils_1.extractTemplateVars)(keyDef.value).forEach((field) => requiredFields.add(field));
-                }
-            }
-            // Process all keys and validate them
-            const resolvedKeys = keys.map((key) => {
-                // Check if all required fields are present
-                const keyRecord = key;
-                const missingFields = Array.from(requiredFields).filter((field) => keyRecord[field] === undefined);
-                if (missingFields.length > 0) {
-                    throw new Error(`[${modelName}] Missing required key field(s) for batchGet(): ${missingFields.join(', ')}. ` +
-                        `Required fields: ${Array.from(requiredFields).join(', ')}`);
-                }
-                // Resolve any key defaults or computed keys
-                return (0, model_utils_1.resolveKeys)(model, key);
-            });
-            // Create the request items in the format expected by BatchGetItem
-            const requestItems = {
-                [tableName]: {
-                    Keys: resolvedKeys,
-                },
-            };
-            return (0, builders_1.createBatchGetBuilder)(requestItems, client, undefined, logger);
-        },
-        batchWrite(items) {
-            // Validate and process all items
-            const processedItems = items.map((item) => {
-                // Validate full input data
-                const parsed = zodSchema.parse(item);
-                // Apply post-processing defaults from the model (including timestamps for new items)
-                const withDefaults = (0, model_utils_1.applyPostDefaults)(model, parsed, {
-                    isUpdate: false,
-                    timestamps,
-                });
-                // Resolve keys again with defaults
-                const fullKey = (0, model_utils_1.resolveKeys)(model, withDefaults);
-                // Combine keys and data into full item, adding _type field
-                return {
-                    ...withDefaults,
-                    ...fullKey,
-                    _type: modelName, // Add entity type identifier
-                };
-            });
-            // Create the request items in the format expected by BatchWriteItem
-            const requestItems = {
-                [tableName]: processedItems.map((item) => ({
-                    PutRequest: {
-                        Item: item,
-                    },
-                })),
-            };
-            return (0, builders_1.createBatchWriteBuilder)(requestItems, client, logger);
-        },
-    };
-};
-exports.createEntityAPI = createEntityAPI;

package/src/entity.ts

@@ -1,337 +0,0 @@
-import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
-import { InferInput, InferKeyInput, InferModel, ModelDefinition } from './core/types';
-import { applyPostDefaults, resolveKeys, extractTemplateVars } from './utils/model-utils';
-import { modelToZod } from './utils/zod-utils';
-import {
-  createGetBuilder,
-  createPutBuilder,
-  createQueryBuilder,
-  createUpdateBuilder,
-  createDeleteBuilder,
-  createScanBuilder,
-  createBatchGetBuilder,
-  createBatchWriteBuilder,
-  GetBuilder,
-  PutBuilder,
-  QueryBuilder,
-  UpdateBuilder,
-  DeleteBuilder,
-  ScanBuilder,
-  BatchGetBuilder,
-  BatchWriteBuilder,
-  WriteRequest,
-} from './builders';
-import { DynamoDBLogger } from './utils/dynamodb-logger';
-
-/**
- * Options for creating the Entity API
- */
-export type EntityAPIOptions = {
-  logger?: DynamoDBLogger;
-  timestamps?: boolean;
-};
-
-/**
- * Entity API interface for a model
- */
-export type EntityAPI<Model, Input, KeyInput, ModelDef extends ModelDefinition = any> = {
-  /**
-   * Retrieves an item by its key.
-   * @param key - Partial or full key object to identify the item
-   * @returns GetBuilder configured for the item
-   */
-  get: (key: KeyInput) => GetBuilder<KeyInput, Model>;
-
-  /**
-   * Puts an item into the table after validation and applying defaults.
-   * @param item - The input data to put
-   * @returns PutBuilder configured for the item
-   */
-  put: (item: Input) => PutBuilder<Model>;
-
-  /**
-   * Queries items using key conditions.
-   * @returns QueryBuilder for building and executing the query
-   */
-  query: () => QueryBuilder<Model, ModelDef>;
-
-  /**
-   * Scans the entire table or index without key conditions.
-   * @returns ScanBuilder for building and executing the scan
-   */
-  scan: () => ScanBuilder<Model>;
-
-  /**
-   * Updates an item by its key.
-   * @param key - Partial or full key object to identify the item
-   * @returns UpdateBuilder configured for the item
-   */
-  update: (key: KeyInput) => UpdateBuilder<Model>;
-
-  /**
-   * Deletes an item by its key.
-   * @param key - Partial or full key object to identify the item
-   * @returns DeleteBuilder configured for the item
-   */
-  delete: (key: KeyInput) => DeleteBuilder<Model>;
-
-  /**
-   * Retrieves multiple items by their keys in a single batch operation.
-   * @param keys - Array of key objects to retrieve
-   * @returns BatchGetBuilder configured for the items
-   */
-  batchGet: (keys: KeyInput[]) => BatchGetBuilder<Model>;
-
-  /**
-   * Writes multiple items in a single batch operation (puts or deletes).
-   * @param items - Array of items to put
-   * @returns BatchWriteBuilder configured for the items
-   */
-  batchWrite: (items: Input[]) => BatchWriteBuilder;
-};
-
-/**
- * Creates an entity API instance with validation, key resolution, and builder creation.
- *
- * @param modelName - The name of the model/entity
- * @param model - The model definition
- * @param client - DynamoDB client instance
- * @param options - Optional configuration (logger, timestamps)
- * @returns EntityAPI with get and put methods
- */
-export const createEntityAPI = <Model extends ModelDefinition>(
-  tableName: string,
-  modelName: string,
-  model: Model,
-  client: DynamoDBClient,
-  options: EntityAPIOptions = {}
-): EntityAPI<InferModel<Model>, InferInput<Model>, InferKeyInput<Model>, Model> => {
-  const { logger, timestamps = false } = options;
-
-  // Build a Zod schema from the model
-  const zodSchema = modelToZod(model);
-
-  return {
-    get(key) {
-      // Extract required fields from key templates
-      const requiredFields = new Set<string>();
-      if (model.key) {
-        for (const keyDef of Object.values(model.key)) {
-          extractTemplateVars(keyDef.value).forEach((field) => requiredFields.add(field));
-        }
-      }
-
-      // Check if all required fields are present
-      const keyRecord = key as Record<string, unknown>;
-      const missingFields = Array.from(requiredFields).filter(
-        (field) => keyRecord[field] === undefined
-      );
-
-      if (missingFields.length > 0) {
-        throw new Error(
-          `[${modelName}] Missing required key field(s) for get(): ${missingFields.join(', ')}. ` +
-            `Required fields: ${Array.from(requiredFields).join(', ')}`
-        );
-      }
-
-      // Resolve any key defaults or computed keys
-      const fullKey = resolveKeys(model, key);
-
-      return createGetBuilder<InferKeyInput<Model>, InferModel<Model>>(
-        tableName,
-        fullKey,
-        client,
-        undefined,
-        logger
-      );
-    },
-
-    put(item) {
-      // Validate full input data
-      const parsed = zodSchema.parse(item);
-
-      // Apply post-processing defaults from the model (including timestamps for new items)
-      const withDefaults = applyPostDefaults(model, parsed, {
-        isUpdate: false,
-        timestamps,
-      });
-
-      // Resolve keys again with defaults
-      const fullKey = resolveKeys(model, withDefaults);
-
-      // Combine keys and data into full item, adding _type field
-      const fullItem = {
-        ...withDefaults,
-        ...fullKey,
-        _type: modelName, // Add entity type identifier
-      };
-
-      return createPutBuilder(tableName, fullItem, client, [], false, 'NONE', false, logger);
-    },
-
-    query() {
-      return createQueryBuilder<InferModel<Model>, Model>(tableName, client, model, logger);
-    },
-
-    scan() {
-      return createScanBuilder<InferModel<Model>>(
-        tableName,
-        client,
-        [],
-        [],
-        undefined,
-        false,
-        undefined,
-        undefined,
-        undefined,
-        logger
-      );
-    },
-
-    update(key) {
-      // Extract required fields from key templates
-      const requiredFields = new Set<string>();
-      if (model.key) {
-        for (const keyDef of Object.values(model.key)) {
-          extractTemplateVars(keyDef.value).forEach((field) => requiredFields.add(field));
-        }
-      }
-
-      // Check if all required fields are present
-      const keyRecord = key as Record<string, unknown>;
-      const missingFields = Array.from(requiredFields).filter(
-        (field) => keyRecord[field] === undefined
-      );
-
-      if (missingFields.length > 0) {
-        throw new Error(
-          `[${modelName}] Missing required key field(s) for update(): ${missingFields.join(', ')}. ` +
-            `Required fields: ${Array.from(requiredFields).join(', ')}`
-        );
-      }
-
-      // Resolve any key defaults or computed keys
-      const fullKey = resolveKeys(model, key);
-
-      return createUpdateBuilder<InferModel<Model>>(
-        tableName,
-        fullKey as Partial<InferModel<Model>>,
-        client,
-        [],
-        { set: [], remove: [], add: [], delete: [] },
-        'NONE',
-        0,
-        timestamps,
-        logger
-      );
-    },
-
-    delete(key) {
-      // Extract required fields from key templates
-      const requiredFields = new Set<string>();
-      if (model.key) {
-        for (const keyDef of Object.values(model.key)) {
-          extractTemplateVars(keyDef.value).forEach((field) => requiredFields.add(field));
-        }
-      }
-
-      // Check if all required fields are present
-      const keyRecord = key as Record<string, unknown>;
-      const missingFields = Array.from(requiredFields).filter(
-        (field) => keyRecord[field] === undefined
-      );
-
-      if (missingFields.length > 0) {
-        throw new Error(
-          `[${modelName}] Missing required key field(s) for delete(): ${missingFields.join(', ')}. ` +
-            `Required fields: ${Array.from(requiredFields).join(', ')}`
-        );
-      }
-
-      // Resolve any key defaults or computed keys
-      const fullKey = resolveKeys(model, key);
-
-      return createDeleteBuilder<InferModel<Model>>(
-        tableName,
-        fullKey as Partial<InferModel<Model>>,
-        client,
-        [],
-        'NONE',
-        logger
-      );
-    },
-
-    batchGet(keys) {
-      // Extract required fields from key templates
-      const requiredFields = new Set<string>();
-      if (model.key) {
-        for (const keyDef of Object.values(model.key)) {
-          extractTemplateVars(keyDef.value).forEach((field) => requiredFields.add(field));
-        }
-      }
-
-      // Process all keys and validate them
-      const resolvedKeys = keys.map((key) => {
-        // Check if all required fields are present
-        const keyRecord = key as Record<string, unknown>;
-        const missingFields = Array.from(requiredFields).filter(
-          (field) => keyRecord[field] === undefined
-        );
-
-        if (missingFields.length > 0) {
-          throw new Error(
-            `[${modelName}] Missing required key field(s) for batchGet(): ${missingFields.join(', ')}. ` +
-              `Required fields: ${Array.from(requiredFields).join(', ')}`
-          );
-        }
-
-        // Resolve any key defaults or computed keys
-        return resolveKeys(model, key);
-      });
-
-      // Create the request items in the format expected by BatchGetItem
-      const requestItems = {
-        [tableName]: {
-          Keys: resolvedKeys,
-        },
-      };
-
-      return createBatchGetBuilder<InferModel<Model>>(requestItems, client, undefined, logger);
-    },
-
-    batchWrite(items) {
-      // Validate and process all items
-      const processedItems = items.map((item) => {
-        // Validate full input data
-        const parsed = zodSchema.parse(item);
-
-        // Apply post-processing defaults from the model (including timestamps for new items)
-        const withDefaults = applyPostDefaults(model, parsed, {
-          isUpdate: false,
-          timestamps,
-        });
-
-        // Resolve keys again with defaults
-        const fullKey = resolveKeys(model, withDefaults);
-
-        // Combine keys and data into full item, adding _type field
-        return {
-          ...withDefaults,
-          ...fullKey,
-          _type: modelName, // Add entity type identifier
-        };
-      });
-
-      // Create the request items in the format expected by BatchWriteItem
-      const requestItems: Record<string, WriteRequest[]> = {
-        [tableName]: processedItems.map((item) => ({
-          PutRequest: {
-            Item: item,
-          },
-        })),
-      };
-
-      return createBatchWriteBuilder(requestItems, client, logger);
-    },
-  };
-};