dyno-table 2.2.1 → 2.3.0

package/dist/entity.cjs

@@ -1,630 +1,19 @@
 'use strict';
 
-// src/builders/entity-aware-builders.ts
-function createEntityAwareBuilder(builder, entityName) {
-  return new Proxy(builder, {
-    get(target, prop, receiver) {
-      if (prop === "entityName") {
-        return entityName;
-      }
-      if (prop === "withBatch" && typeof target[prop] === "function") {
-        return (batch, entityType) => {
-          const typeToUse = entityType ?? entityName;
-          const fn = target[prop];
-          return fn.call(target, batch, typeToUse);
-        };
-      }
-      return Reflect.get(target, prop, receiver);
-    }
-  });
-}
-function createEntityAwarePutBuilder(builder, entityName) {
-  return createEntityAwareBuilder(builder, entityName);
-}
-function createEntityAwareGetBuilder(builder, entityName) {
-  return createEntityAwareBuilder(builder, entityName);
-}
-function createEntityAwareDeleteBuilder(builder, entityName) {
-  return createEntityAwareBuilder(builder, entityName);
-}
-var EntityAwareUpdateBuilder = class {
-  forceRebuildIndexes = [];
-  entityName;
-  builder;
-  entityConfig;
-  updateDataApplied = false;
-  constructor(builder, entityName) {
-    this.builder = builder;
-    this.entityName = entityName;
-  }
-  /**
-   * Configure entity-specific logic for automatic timestamp generation and index updates
-   */
-  configureEntityLogic(config) {
-    this.entityConfig = config;
-  }
-  /**
-   * Forces a rebuild of one or more readonly indexes during the update operation.
-   *
-   * By default, readonly indexes are not updated during entity updates to prevent
-   * errors when required index attributes are missing. This method allows you to
-   * override that behavior and force specific indexes to be rebuilt.
-   *
-   * @example
-   * ```typescript
-   * // Force rebuild a single readonly index
-   * const result = await repo.update({ id: 'TREX-001' }, { status: 'ACTIVE' })
-   *   .forceIndexRebuild('gsi1')
-   *   .execute();
-   *
-   * // Force rebuild multiple readonly indexes
-   * const result = await repo.update({ id: 'TREX-001' }, { status: 'ACTIVE' })
-   *   .forceIndexRebuild(['gsi1', 'gsi2'])
-   *   .execute();
-   *
-   * // Chain with other update operations
-   * const result = await repo.update({ id: 'TREX-001' }, { status: 'ACTIVE' })
-   *   .set('lastUpdated', new Date().toISOString())
-   *   .forceIndexRebuild('gsi1')
-   *   .condition(op => op.eq('status', 'INACTIVE'))
-   *   .execute();
-   * ```
-   *
-   * @param indexes - A single index name or array of index names to force rebuild
-   * @returns The builder instance for method chaining
-   */
-  forceIndexRebuild(indexes) {
-    if (Array.isArray(indexes)) {
-      this.forceRebuildIndexes = [...this.forceRebuildIndexes, ...indexes];
-    } else {
-      this.forceRebuildIndexes.push(indexes);
-    }
-    return this;
-  }
-  /**
-   * Gets the list of indexes that should be force rebuilt.
-   * This is used internally by entity update logic.
-   *
-   * @returns Array of index names to force rebuild
-   */
-  getForceRebuildIndexes() {
-    return [...this.forceRebuildIndexes];
-  }
-  /**
-   * Apply entity-specific update data (timestamps and index updates)
-   * This is called automatically when needed
-   */
-  applyEntityUpdates() {
-    if (!this.entityConfig || this.updateDataApplied) return;
-    const timestamps = this.entityConfig.generateTimestamps();
-    const updatedItem = { ...this.entityConfig.key, ...this.entityConfig.data, ...timestamps };
-    const indexUpdates = this.entityConfig.buildIndexUpdates(
-      this.entityConfig.key,
-      updatedItem,
-      this.entityConfig.table,
-      this.entityConfig.indexes,
-      this.forceRebuildIndexes
-    );
-    this.builder.set({ ...this.entityConfig.data, ...timestamps, ...indexUpdates });
-    this.updateDataApplied = true;
-  }
-  set(valuesOrPath, value) {
-    if (typeof valuesOrPath === "object") {
-      this.builder.set(valuesOrPath);
-    } else {
-      if (value === void 0) {
-        throw new Error("Value is required when setting a single path");
-      }
-      this.builder.set(valuesOrPath, value);
-    }
-    return this;
-  }
-  remove(path) {
-    this.builder.remove(path);
-    return this;
-  }
-  add(path, value) {
-    this.builder.add(path, value);
-    return this;
-  }
-  deleteElementsFromSet(path, value) {
-    this.builder.deleteElementsFromSet(path, value);
-    return this;
-  }
-  condition(condition) {
-    this.builder.condition(condition);
-    return this;
-  }
-  returnValues(returnValues) {
-    this.builder.returnValues(returnValues);
-    return this;
-  }
-  toDynamoCommand() {
-    return this.builder.toDynamoCommand();
-  }
-  withTransaction(transaction) {
-    this.applyEntityUpdates();
-    this.builder.withTransaction(transaction);
-  }
-  debug() {
-    return this.builder.debug();
-  }
-  async execute() {
-    this.updateDataApplied = false;
-    this.applyEntityUpdates();
-    return this.builder.execute();
-  }
-};
-function createEntityAwareUpdateBuilder(builder, entityName) {
-  return new EntityAwareUpdateBuilder(builder, entityName);
-}
+var chunkNTA6GDPP_cjs = require('./chunk-NTA6GDPP.cjs');
+require('./chunk-7UJJ7JXM.cjs');
 
-// src/conditions.ts
-var createComparisonCondition = (type) => (attr, value) => ({
-  type,
-  attr,
-  value
-});
-var eq = createComparisonCondition("eq");
-
-// src/entity/ddb-indexing.ts
-var IndexBuilder = class {
-  /**
-   * Creates a new IndexBuilder instance
-   *
-   * @param table - The DynamoDB table instance
-   * @param indexes - The index definitions
-   */
-  constructor(table, indexes = {}) {
-    this.table = table;
-    this.indexes = indexes;
-  }
-  /**
-   * Build index attributes for item creation
-   *
-   * @param item - The item to generate indexes for
-   * @param options - Options for building indexes
-   * @returns Record of GSI attribute names to their values
-   */
-  buildForCreate(item, options = {}) {
-    const attributes = {};
-    for (const [indexName, indexDef] of Object.entries(this.indexes)) {
-      if (options.excludeReadOnly && indexDef.isReadOnly) {
-        continue;
-      }
-      const key = indexDef.generateKey(item);
-      const gsiConfig = this.table.gsis[indexName];
-      if (!gsiConfig) {
-        throw new Error(`GSI configuration not found for index: ${indexName}`);
-      }
-      if (key.pk) {
-        attributes[gsiConfig.partitionKey] = key.pk;
-      }
-      if (key.sk && gsiConfig.sortKey) {
-        attributes[gsiConfig.sortKey] = key.sk;
-      }
-    }
-    return attributes;
-  }
-  /**
-   * Build index attributes for item updates
-   *
-   * @param currentData - The current data before update
-   * @param updates - The update data
-   * @param options - Options for building indexes
-   * @returns Record of GSI attribute names to their updated values
-   */
-  buildForUpdate(currentData, updates, options = {}) {
-    const attributes = {};
-    const updatedItem = { ...currentData, ...updates };
-    if (options.forceRebuildIndexes && options.forceRebuildIndexes.length > 0) {
-      const invalidIndexes = options.forceRebuildIndexes.filter((indexName) => !this.indexes[indexName]);
-      if (invalidIndexes.length > 0) {
-        throw new Error(
-          `Cannot force rebuild unknown indexes: ${invalidIndexes.join(", ")}. Available indexes: ${Object.keys(this.indexes).join(", ")}`
-        );
-      }
-    }
-    for (const [indexName, indexDef] of Object.entries(this.indexes)) {
-      const isForced = options.forceRebuildIndexes?.includes(indexName);
-      if (indexDef.isReadOnly && !isForced) {
-        continue;
-      }
-      if (!isForced) {
-        let shouldUpdateIndex = false;
-        try {
-          const currentKey = indexDef.generateKey(currentData);
-          const updatedKey = indexDef.generateKey(updatedItem);
-          if (currentKey.pk !== updatedKey.pk || currentKey.sk !== updatedKey.sk) {
-            shouldUpdateIndex = true;
-          }
-        } catch {
-          shouldUpdateIndex = true;
-        }
-        if (!shouldUpdateIndex) {
-          continue;
-        }
-      }
-      let key;
-      try {
-        key = indexDef.generateKey(updatedItem);
-      } catch (error) {
-        if (error instanceof Error) {
-          throw new Error(`Missing attributes: ${error.message}`);
-        }
-        throw error;
-      }
-      if (this.hasUndefinedValues(key)) {
-        throw new Error(
-          `Missing attributes: Cannot update entity: insufficient data to regenerate index "${indexName}". All attributes required by the index must be provided in the update operation, or the index must be marked as readOnly.`
-        );
-      }
-      const gsiConfig = this.table.gsis[indexName];
-      if (!gsiConfig) {
-        throw new Error(`GSI configuration not found for index: ${indexName}`);
-      }
-      if (key.pk) {
-        attributes[gsiConfig.partitionKey] = key.pk;
-      }
-      if (key.sk && gsiConfig.sortKey) {
-        attributes[gsiConfig.sortKey] = key.sk;
-      }
-    }
-    return attributes;
-  }
-  /**
-   * Check if a key has undefined values
-   *
-   * @param key - The index key to check
-   * @returns True if the key contains undefined values, false otherwise
-   */
-  hasUndefinedValues(key) {
-    return (key.pk?.includes("undefined") ?? false) || (key.sk?.includes("undefined") ?? false);
-  }
-};
-
-// src/entity/index-utils.ts
-function buildIndexes(dataForKeyGeneration, table, indexes, excludeReadOnly = false) {
-  if (!indexes) {
-    return {};
-  }
-  const indexBuilder = new IndexBuilder(table, indexes);
-  return indexBuilder.buildForCreate(dataForKeyGeneration, { excludeReadOnly });
-}
-function buildIndexUpdates(currentData, updates, table, indexes, forceRebuildIndexes) {
-  if (!indexes) {
-    return {};
-  }
-  const indexBuilder = new IndexBuilder(table, indexes);
-  return indexBuilder.buildForUpdate(currentData, updates, { forceRebuildIndexes });
-}
 
-// src/entity/entity.ts
-function defineEntity(config) {
-  const entityTypeAttributeName = config.settings?.entityTypeAttributeName ?? "entityType";
-  const buildIndexes2 = (dataForKeyGeneration, table, excludeReadOnly = false) => {
-    return buildIndexes(dataForKeyGeneration, table, config.indexes, excludeReadOnly);
-  };
-  const wrapMethodWithPreparation = (originalMethod, prepareFn, context) => {
-    const wrappedMethod = (...args) => {
-      prepareFn();
-      return originalMethod.call(context, ...args);
-    };
-    Object.setPrototypeOf(wrappedMethod, originalMethod);
-    const propertyNames = Object.getOwnPropertyNames(originalMethod);
-    for (let i = 0; i < propertyNames.length; i++) {
-      const prop = propertyNames[i];
-      if (prop !== "length" && prop !== "name" && prop !== "prototype") {
-        const descriptor = Object.getOwnPropertyDescriptor(originalMethod, prop);
-        if (descriptor && descriptor.writable !== false && !descriptor.get) {
-          wrappedMethod[prop] = originalMethod[prop];
-        }
-      }
-    }
-    return wrappedMethod;
-  };
-  const generateTimestamps = (timestampsToGenerate, data) => {
-    if (!config.settings?.timestamps) return {};
-    const timestamps = {};
-    const now = /* @__PURE__ */ new Date();
-    const unixTime = Math.floor(Date.now() / 1e3);
-    const { createdAt, updatedAt } = config.settings.timestamps;
-    if (createdAt && timestampsToGenerate.includes("createdAt") && !data.createdAt) {
-      const name = createdAt.attributeName ?? "createdAt";
-      timestamps[name] = createdAt.format === "UNIX" ? unixTime : now.toISOString();
-    }
-    if (updatedAt && timestampsToGenerate.includes("updatedAt") && !data.updatedAt) {
-      const name = updatedAt.attributeName ?? "updatedAt";
-      timestamps[name] = updatedAt.format === "UNIX" ? unixTime : now.toISOString();
-    }
-    return timestamps;
-  };
-  return {
-    name: config.name,
-    createRepository: (table) => {
-      const repository = {
-        create: (data) => {
-          const builder = table.create({});
-          const prepareValidatedItemAsync = async () => {
-            const validatedData = await config.schema["~standard"].validate(data);
-            if ("issues" in validatedData && validatedData.issues) {
-              throw new Error(`Validation failed: ${validatedData.issues.map((i) => i.message).join(", ")}`);
-            }
-            const dataForKeyGeneration = {
-              ...validatedData.value,
-              ...generateTimestamps(["createdAt", "updatedAt"], validatedData.value)
-            };
-            const primaryKey = config.primaryKey.generateKey(dataForKeyGeneration);
-            const indexes = buildIndexes(dataForKeyGeneration, table, config.indexes, false);
-            const validatedItem = {
-              ...dataForKeyGeneration,
-              [entityTypeAttributeName]: config.name,
-              [table.partitionKey]: primaryKey.pk,
-              ...table.sortKey ? { [table.sortKey]: primaryKey.sk } : {},
-              ...indexes
-            };
-            Object.assign(builder, { item: validatedItem });
-            return validatedItem;
-          };
-          const prepareValidatedItemSync = () => {
-            const validationResult = config.schema["~standard"].validate(data);
-            if (validationResult instanceof Promise) {
-              throw new Error(
-                "Async validation is not supported in withBatch or withTransaction. The schema must support synchronous validation for compatibility."
-              );
-            }
-            if ("issues" in validationResult && validationResult.issues) {
-              throw new Error(`Validation failed: ${validationResult.issues.map((i) => i.message).join(", ")}`);
-            }
-            const dataForKeyGeneration = {
-              ...validationResult.value,
-              ...generateTimestamps(["createdAt", "updatedAt"], validationResult.value)
-            };
-            const primaryKey = config.primaryKey.generateKey(dataForKeyGeneration);
-            const indexes = buildIndexes(dataForKeyGeneration, table, config.indexes, false);
-            const validatedItem = {
-              ...dataForKeyGeneration,
-              [entityTypeAttributeName]: config.name,
-              [table.partitionKey]: primaryKey.pk,
-              ...table.sortKey ? { [table.sortKey]: primaryKey.sk } : {},
-              ...indexes
-            };
-            Object.assign(builder, { item: validatedItem });
-            return validatedItem;
-          };
-          const originalExecute = builder.execute;
-          builder.execute = async () => {
-            await prepareValidatedItemAsync();
-            return await originalExecute.call(builder);
-          };
-          const originalWithTransaction = builder.withTransaction;
-          if (originalWithTransaction) {
-            builder.withTransaction = wrapMethodWithPreparation(
-              originalWithTransaction,
-              prepareValidatedItemSync,
-              builder
-            );
-          }
-          const originalWithBatch = builder.withBatch;
-          if (originalWithBatch) {
-            builder.withBatch = wrapMethodWithPreparation(originalWithBatch, prepareValidatedItemSync, builder);
-          }
-          return createEntityAwarePutBuilder(builder, config.name);
-        },
-        upsert: (data) => {
-          const builder = table.put({});
-          const prepareValidatedItemAsync = async () => {
-            const validatedData = await config.schema["~standard"].validate(data);
-            if ("issues" in validatedData && validatedData.issues) {
-              throw new Error(`Validation failed: ${validatedData.issues.map((i) => i.message).join(", ")}`);
-            }
-            const dataForKeyGeneration = {
-              ...validatedData.value,
-              ...generateTimestamps(["createdAt", "updatedAt"], validatedData.value)
-            };
-            const primaryKey = config.primaryKey.generateKey(dataForKeyGeneration);
-            const indexes = buildIndexes2(dataForKeyGeneration, table, false);
-            const validatedItem = {
-              [table.partitionKey]: primaryKey.pk,
-              ...table.sortKey ? { [table.sortKey]: primaryKey.sk } : {},
-              ...dataForKeyGeneration,
-              [entityTypeAttributeName]: config.name,
-              ...indexes
-            };
-            Object.assign(builder, { item: validatedItem });
-            return validatedItem;
-          };
-          const prepareValidatedItemSync = () => {
-            const validationResult = config.schema["~standard"].validate(data);
-            if (validationResult instanceof Promise) {
-              throw new Error(
-                "Async validation is not supported in withTransaction or withBatch. Use execute() instead."
-              );
-            }
-            if ("issues" in validationResult && validationResult.issues) {
-              throw new Error(`Validation failed: ${validationResult.issues.map((i) => i.message).join(", ")}`);
-            }
-            const dataForKeyGeneration = {
-              ...validationResult.value,
-              ...generateTimestamps(["createdAt", "updatedAt"], validationResult.value)
-            };
-            const primaryKey = config.primaryKey.generateKey(dataForKeyGeneration);
-            const indexes = buildIndexes(dataForKeyGeneration, table, config.indexes, false);
-            const validatedItem = {
-              [table.partitionKey]: primaryKey.pk,
-              ...table.sortKey ? { [table.sortKey]: primaryKey.sk } : {},
-              ...dataForKeyGeneration,
-              [entityTypeAttributeName]: config.name,
-              ...indexes
-            };
-            Object.assign(builder, { item: validatedItem });
-            return validatedItem;
-          };
-          const originalExecute = builder.execute;
-          builder.execute = async () => {
-            await prepareValidatedItemAsync();
-            const result = await originalExecute.call(builder);
-            if (!result) {
-              throw new Error("Failed to upsert item");
-            }
-            return result;
-          };
-          const originalWithTransaction = builder.withTransaction;
-          if (originalWithTransaction) {
-            builder.withTransaction = wrapMethodWithPreparation(
-              originalWithTransaction,
-              prepareValidatedItemSync,
-              builder
-            );
-          }
-          const originalWithBatch = builder.withBatch;
-          if (originalWithBatch) {
-            builder.withBatch = wrapMethodWithPreparation(originalWithBatch, prepareValidatedItemSync, builder);
-          }
-          return createEntityAwarePutBuilder(builder, config.name);
-        },
-        get: (key) => {
-          return createEntityAwareGetBuilder(table.get(config.primaryKey.generateKey(key)), config.name);
-        },
-        update: (key, data) => {
-          const primaryKeyObj = config.primaryKey.generateKey(key);
-          const builder = table.update(primaryKeyObj);
-          builder.condition(eq(entityTypeAttributeName, config.name));
-          const entityAwareBuilder = createEntityAwareUpdateBuilder(builder, config.name);
-          entityAwareBuilder.configureEntityLogic({
-            data,
-            key,
-            table,
-            indexes: config.indexes,
-            generateTimestamps: () => generateTimestamps(["updatedAt"], data),
-            buildIndexUpdates
-          });
-          return entityAwareBuilder;
-        },
-        delete: (key) => {
-          const builder = table.delete(config.primaryKey.generateKey(key));
-          builder.condition(eq(entityTypeAttributeName, config.name));
-          return createEntityAwareDeleteBuilder(builder, config.name);
-        },
-        query: Object.entries(config.queries || {}).reduce((acc, [key, inputCallback]) => {
-          acc[key] = (input) => {
-            const queryEntity = {
-              scan: repository.scan,
-              get: (key2) => createEntityAwareGetBuilder(table.get(key2), config.name),
-              query: (keyCondition) => {
-                return table.query(keyCondition);
-              }
-            };
-            const queryBuilderCallback = inputCallback(input);
-            const builder = queryBuilderCallback(queryEntity);
-            if (builder && typeof builder === "object" && "filter" in builder && typeof builder.filter === "function") {
-              builder.filter(eq(entityTypeAttributeName, config.name));
-            }
-            if (builder && typeof builder === "object" && "execute" in builder) {
-              const originalExecute = builder.execute;
-              builder.execute = async () => {
-                const queryFn = config.queries[key];
-                if (queryFn && typeof queryFn === "function") {
-                  const schema = queryFn.schema;
-                  if (schema?.["~standard"]?.validate && typeof schema["~standard"].validate === "function") {
-                    const validationResult = schema["~standard"].validate(input);
-                    if ("issues" in validationResult && validationResult.issues) {
-                      throw new Error(
-                        `Validation failed: ${validationResult.issues.map((issue) => issue.message).join(", ")}`
-                      );
-                    }
-                  }
-                }
-                const result = await originalExecute.call(builder);
-                if (!result) {
-                  throw new Error("Failed to execute query");
-                }
-                return result;
-              };
-            }
-            return builder;
-          };
-          return acc;
-        }, {}),
-        scan: () => {
-          const builder = table.scan();
-          builder.filter(eq(entityTypeAttributeName, config.name));
-          return builder;
-        }
-      };
-      return repository;
-    }
-  };
-}
-function createQueries() {
-  return {
-    input: (schema) => ({
-      query: (handler) => {
-        const queryFn = (input) => (entity) => handler({ input, entity });
-        queryFn.schema = schema;
-        return queryFn;
-      }
-    })
-  };
-}
-function createIndex() {
-  return {
-    input: (schema) => {
-      const createIndexBuilder = (isReadOnly = false) => ({
-        partitionKey: (pkFn) => ({
-          sortKey: (skFn) => {
-            const index = {
-              name: "custom",
-              partitionKey: "pk",
-              sortKey: "sk",
-              isReadOnly,
-              generateKey: (item) => {
-                const data = schema["~standard"].validate(item);
-                if ("issues" in data && data.issues) {
-                  throw new Error(`Index validation failed: ${data.issues.map((i) => i.message).join(", ")}`);
-                }
-                const validData = "value" in data ? data.value : item;
-                return { pk: pkFn(validData), sk: skFn(validData) };
-              }
-            };
-            return Object.assign(index, {
-              readOnly: (value = false) => ({
-                ...index,
-                isReadOnly: value
-              })
-            });
-          },
-          withoutSortKey: () => {
-            const index = {
-              name: "custom",
-              partitionKey: "pk",
-              isReadOnly,
-              generateKey: (item) => {
-                const data = schema["~standard"].validate(item);
-                if ("issues" in data && data.issues) {
-                  throw new Error(`Index validation failed: ${data.issues.map((i) => i.message).join(", ")}`);
-                }
-                const validData = "value" in data ? data.value : item;
-                return { pk: pkFn(validData) };
-              }
-            };
-            return Object.assign(index, {
-              readOnly: (value = true) => ({
-                ...index,
-                isReadOnly: value
-              })
-            });
-          }
-        }),
-        readOnly: (value = true) => createIndexBuilder(value)
-      });
-      return createIndexBuilder(false);
-    }
-  };
-}
 
-exports.createIndex = createIndex;
-exports.createQueries = createQueries;
-exports.defineEntity = defineEntity;
-//# sourceMappingURL=entity.cjs.map
-//# sourceMappingURL=entity.cjs.map
+Object.defineProperty(exports, "createIndex", {
+  enumerable: true,
+  get: function () { return chunkNTA6GDPP_cjs.createIndex; }
+});
+Object.defineProperty(exports, "createQueries", {
+  enumerable: true,
+  get: function () { return chunkNTA6GDPP_cjs.createQueries; }
+});
+Object.defineProperty(exports, "defineEntity", {
+  enumerable: true,
+  get: function () { return chunkNTA6GDPP_cjs.defineEntity; }
+});

package/dist/entity.d.cts

@@ -1,17 +1,9 @@
 import { s as Path, t as PathType, a as Condition, b as ConditionOperator, c as PrimaryKeyWithoutExpression, P as PrimaryKey } from './conditions-CcZL0sR2.cjs';
-import { G as GetBuilder } from './batch-builder-BiQDIZ7p.cjs';
-import { Q as QueryBuilder } from './query-builder-D3URwK9k.cjs';
-import { T as Table, S as ScanBuilder } from './table-ClST8nkR.cjs';
+import { P as PutBuilder, G as GetBuilder, U as UpdateBuilder, i as UpdateCommandParams, T as TransactionBuilder, D as DeleteBuilder, S as ScanBuilder, Q as QueryBuilder } from './index-DlN8G9hd.cjs';
 import { StandardSchemaV1 } from './standard-schema.cjs';
+import { Table } from './table.cjs';
 import { DynamoItem, TableConfig, Index } from './types.cjs';
-import { U as UpdateCommandParams } from './builder-types-BTVhQSHI.cjs';
-import { DeleteBuilder } from './builders/delete-builder.cjs';
-import { PutBuilder } from './builders/put-builder.cjs';
-import { TransactionBuilder } from './builders/transaction-builder.cjs';
-import { UpdateBuilder } from './builders/update-builder.cjs';
-import './builders/paginator.cjs';
 import '@aws-sdk/lib-dynamodb';
-import './builders/condition-check-builder.cjs';
 
 type SetElementType<T> = T extends Set<infer U> ? U : T extends Array<infer U> ? U : never;
 type PathSetElementType<T, K extends Path<T>> = SetElementType<PathType<T, K>>;

package/dist/entity.d.ts

@@ -1,17 +1,9 @@
 import { s as Path, t as PathType, a as Condition, b as ConditionOperator, c as PrimaryKeyWithoutExpression, P as PrimaryKey } from './conditions-D_w7vVYG.js';
-import { G as GetBuilder } from './batch-builder-CNsLS6sR.js';
-import { Q as QueryBuilder } from './query-builder-cfEkU0_w.js';
-import { T as Table, S as ScanBuilder } from './table-vE3cGoDy.js';
+import { P as PutBuilder, G as GetBuilder, U as UpdateBuilder, i as UpdateCommandParams, T as TransactionBuilder, D as DeleteBuilder, S as ScanBuilder, Q as QueryBuilder } from './index-2cbm07Bi.js';
 import { StandardSchemaV1 } from './standard-schema.js';
+import { Table } from './table.js';
 import { DynamoItem, TableConfig, Index } from './types.js';
-import { U as UpdateCommandParams } from './builder-types-CzuLR4Th.js';
-import { DeleteBuilder } from './builders/delete-builder.js';
-import { PutBuilder } from './builders/put-builder.js';
-import { TransactionBuilder } from './builders/transaction-builder.js';
-import { UpdateBuilder } from './builders/update-builder.js';
-import './builders/paginator.js';
 import '@aws-sdk/lib-dynamodb';
-import './builders/condition-check-builder.js';
 
 type SetElementType<T> = T extends Set<infer U> ? U : T extends Array<infer U> ? U : never;
 type PathSetElementType<T, K extends Path<T>> = SetElementType<PathType<T, K>>;