aws-service-stack 0.10.92

package/dist/provider/opensearch.js

@@ -0,0 +1,34 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ESClientOpenSearch = void 0;
+const opensearch_1 = require("@opensearch-project/opensearch");
+const credential_provider_node_1 = require("@aws-sdk/credential-provider-node");
+const aws_1 = require("@opensearch-project/opensearch/aws");
+const index_1 = require("../index");
+const typedi_1 = require("typedi");
+let ESClientOpenSearch = class ESClientOpenSearch extends opensearch_1.Client {
+    constructor() {
+        super(Object.assign(Object.assign({}, (0, aws_1.AwsSigv4Signer)({
+            region: (0, index_1.getEnvVariable)("AWS_REGION", new Error("AWS_REGION_NOT_FOUND")),
+            getCredentials: () => {
+                const credentialsProvider = (0, credential_provider_node_1.defaultProvider)();
+                return credentialsProvider();
+            },
+        })), { node: (0, index_1.getEnvVariable)("OPENSEARCH_ENDPOINT", new Error("OPENSEARCH_ENDPOINT_NOT_FOUND")) }));
+    }
+};
+exports.ESClientOpenSearch = ESClientOpenSearch;
+exports.ESClientOpenSearch = ESClientOpenSearch = __decorate([
+    (0, typedi_1.Service)("ESClientOpenSearch"),
+    __metadata("design:paramtypes", [])
+], ESClientOpenSearch);
+//# sourceMappingURL=opensearch.js.map

package/dist/provider/opensearch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"opensearch.js","sourceRoot":"","sources":["../../src/provider/opensearch.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,+DAAwD;AACxD,gFAAoE;AACpE,4DAAoE;AACpE,oCAA0C;AAC1C,mCAAiC;AAG1B,IAAM,kBAAkB,GAAxB,MAAM,kBAAmB,SAAQ,mBAAM;IAC5C;QACE,KAAK,iCACA,IAAA,oBAAc,EAAC;YAChB,MAAM,EAAE,IAAA,sBAAc,EAAC,YAAY,EAAE,IAAI,KAAK,CAAC,sBAAsB,CAAC,CAAC;YACvE,cAAc,EAAE,GAAG,EAAE;gBACnB,MAAM,mBAAmB,GAAG,IAAA,0CAAe,GAAE,CAAC;gBAC9C,OAAO,mBAAmB,EAAE,CAAC;YAC/B,CAAC;SACF,CAAC,KACF,IAAI,EAAE,IAAA,sBAAc,EAAC,qBAAqB,EAAE,IAAI,KAAK,CAAC,+BAA+B,CAAC,CAAC,IACvF,CAAC;IACL,CAAC;CACF,CAAA;AAbY,gDAAkB;6BAAlB,kBAAkB;IAD9B,IAAA,gBAAO,EAAC,oBAAoB,CAAC;;GACjB,kBAAkB,CAa9B"}

package/dist/repositories/base-core.repo.interface.d.ts

@@ -0,0 +1,129 @@
+import { BaseEntity, FilterAndSort, List } from "../model/index.js";
+/**
+ * Core repository interface defining standard CRUD and query operations.
+ * Designed to be implemented for different data sources such as DynamoDB or OpenSearch.
+ */
+export interface CoreRepo<T extends BaseEntity> {
+    /**
+     * Saves an entity by either creating it (if it does not exist) or updating it (if it does).
+     *
+     * @param entity - The entity to save.
+     * @returns The saved entity.
+     */
+    save(entity: Partial<T>): Promise<T>;
+    /**
+     * Saves multiple entities by either creating or updating each one.
+     *
+     * @param entities - An array of entities to save.
+     * @returns An array of saved entities.
+     */
+    saveMany(entities: Partial<T>[]): Promise<Partial<T>[]>;
+    /**
+     * Updates an existing entity.
+     * Fails if the entity does not exist.
+     *
+     * @param entity - The entity with updated data.
+     * @param fieldNames - The list of field names to update in the entity.
+     * @returns The updated entity.
+     */
+    update(entity: Partial<T>, fieldNames: string[]): Promise<T>;
+    /**
+     * Updates multiple existing entities.
+     *
+     * If `fieldNames` is **not provided**, the method performs a **batch update**
+     * (e.g., using `BatchWriteItem` in DynamoDB, if supported). In this case, entire entities
+     * are replaced or merged as a whole.
+     *
+     * If `fieldNames` **is provided**, each entity is updated individually, and only the
+     * specified fields in `fieldNames` will be modified. This approach avoids overwriting
+     * the entire entity and is useful for partial updates.
+     *
+     * Note:
+     * - Entities must already exist in the data store.
+     * - Batch update is not truly atomic; some partial updates may occur if errors happen mid-way.
+     * - If partial field updates are needed, `fieldNames` must be used.
+     *
+     * @param entities - An array of entities with partial data to update.
+     * @param fieldNames - Optional list of field names to update. If provided, only these fields are updated per entity.
+     * @returns An array of successfully updated entities.
+     */
+    updateMany(entities: Partial<T>[], fieldNames: string[]): Promise<boolean>;
+    /**
+     * Deletes an entity by its unique identifier.
+     *
+     * @param id - The ID of the entity to delete.
+     * @returns True if the entity was successfully deleted; otherwise, false.
+     */
+    delete(id: string): Promise<boolean>;
+    /**
+     * Deletes multiple entities by their unique identifiers.
+     *
+     * @param ids - An array of entity IDs to delete.
+     * @returns True if all entities were successfully deleted; otherwise, false.
+     */
+    deleteMany(ids: string[]): Promise<boolean>;
+    /**
+     * Checks whether an entity with the specified ID exists.
+     *
+     * @param id - The ID of the entity to check.
+     * @returns True if the entity exists; otherwise, false.
+     */
+    exists(id: string): Promise<boolean>;
+    /**
+     * Retrieves a single entity by its unique identifier.
+     *
+     * @param id - The ID of the entity to retrieve.
+     * @returns The entity if found; otherwise, null.
+     */
+    findById(id: string): Promise<T | null>;
+    /**
+     * Retrieves multiple entities by their unique identifiers.
+     * Returns only the entities that exist (non-existent IDs are ignored).
+     *
+     * @param ids - An array of entity IDs to retrieve.
+     * @returns An array of entities that were found.
+     */
+    findByIds(ids: string[]): Promise<T[]>;
+    /**
+     * Retrieves a list of entities that match the specified filter, sorting, and pagination criteria.
+     *
+     * @param filter - Filtering, sorting, and pagination options.
+     * @returns An array of matching entities.
+     */
+    find(filter: FilterAndSort): Promise<List<Partial<T>>>;
+    /**
+     * Retrieves the first matching entity based on the specified filter.
+     *
+     * @param filter - Filtering criteria.
+     * @returns The first matching entity if found; otherwise, null.
+     */
+    findOne(filter: FilterAndSort): Promise<Partial<T> | null>;
+    /**
+     * Counts the total number of entities matching the specified filter.
+     * Useful for pagination and statistics.
+     *
+     * @param filter - Filtering criteria.
+     * @returns The number of matching entities.
+     */
+    count(filter: FilterAndSort): Promise<number>;
+    /**
+     * (Optional) Returns the raw response from the data source.
+     * Useful for debugging or exposing advanced querying features (e.g., OpenSearch DSL).
+     *
+     * @param filter - Filtering and query options.
+     * @returns A raw result object from the data source.
+     */
+    getRaw?(filter: FilterAndSort): Promise<any>;
+    /**
+     * Adjusts a numeric field in the database by adding or subtracting a specified value.
+     * If the field does not exist, it will be initialized to zero before applying the adjustment.
+     *
+     * @param id - The unique identifier of the item to update.
+     * @param fieldName - The name of the numeric field to modify.
+     * @param delta - The amount to add (positive) or subtract (negative) from the field.
+     * @returns The updated item after the adjustment.
+     * @throws Will throw an error if the id is not provided.
+     */
+    incrementValueByField(entityId: string, fieldName: string, value?: number): Promise<T>;
+    decrementValueByField(entityId: string, fieldName: string, value?: number): Promise<T>;
+}

package/dist/repositories/base-core.repo.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=base-core.repo.interface.js.map

package/dist/repositories/base-core.repo.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-core.repo.interface.js","sourceRoot":"","sources":["../../src/repositories/base-core.repo.interface.ts"],"names":[],"mappings":""}

package/dist/repositories/base-db.repo.d.ts

@@ -0,0 +1,78 @@
+import { BaseEntity, BaseRepoDB, DynamoIndexMap, FilterAndSort, List } from "../index";
+export declare class BaseRepoDBImpl<T extends BaseEntity> implements BaseRepoDB<T> {
+    private readonly dynamoDb;
+    private _tableName;
+    private _indexMap;
+    private DYNAMO_QUERY_LIMIT;
+    constructor(tableName: string, indexMap: DynamoIndexMap);
+    incrementValueByField(entityId: string, fieldName: string, value?: number): Promise<T>;
+    decrementValueByField(entityId: string, fieldName: string, value?: number): Promise<T>;
+    transactWrite?(operations: any[]): Promise<boolean>;
+    update(entity: Partial<T>, fieldNames: string[]): Promise<T>;
+    updateMany(entityList: Partial<T>[], fieldNames: string[]): Promise<boolean>;
+    save(entity: Partial<T>): Promise<T>;
+    saveMany(entities: Partial<T>[]): Promise<Partial<T>[]>;
+    delete(id: string): Promise<boolean>;
+    deleteMany(ids: string[]): Promise<boolean>;
+    findById(id: string): Promise<T>;
+    findByIds(ids: string[]): Promise<T[]>;
+    find(filter: FilterAndSort): Promise<List<Partial<T>>>;
+    findOne(filter: FilterAndSort): Promise<T>;
+    findByIndex(indexName: string, value: string): Promise<List<Partial<T>>>;
+    count(filter: FilterAndSort): Promise<number>;
+    exists(id: string): Promise<boolean>;
+    getRaw(filter: FilterAndSort): Promise<any>;
+    transactionRead<T>(operations: {
+        id: string;
+        sortKey?: string;
+    }[]): Promise<T[]>;
+    transactRead?<TResult = any>(operations: any[]): Promise<TResult[]>;
+    transactionWrite(operations: {
+        create?: {
+            tableName: string;
+            item: Record<string, any>;
+        }[];
+        update?: {
+            tableName: string;
+            key: {
+                id: string;
+            };
+            updateData: Record<string, any>;
+        }[];
+        delete?: {
+            tableName: string;
+            key: {
+                id: string;
+            };
+        }[];
+    }): Promise<boolean>;
+    getTableName(): string;
+    setIndexMap(indexMap: DynamoIndexMap): boolean;
+    setTableName(tableName: string): boolean;
+    getIndexMap(): DynamoIndexMap;
+    private incrementOrDecrementFieldValue;
+    /**
+     * Executes a DynamoDB Query or Scan operation and returns a guaranteed number of results up to the specified limit.
+     *
+     * DynamoDB's native `Limit` parameter defines the *maximum amount of data* to return, not necessarily the *number of items*,
+     * due to its internal 1 MB response size limit. This method continues pagination using `LastEvaluatedKey` until the desired
+     * number of items is retrieved or no more results are available.
+     *
+     * @param queryInput - The DynamoDB QueryCommandInput or ScanCommandInput.
+     * @param startKey - Optional key to start the query from (for pagination).
+     * @returns A item list of type `T`, guaranteed to contain up to `Limit` items if available.
+     */ private sendCommandDeep;
+    /**
+     * Executes a single DynamoDB Query or Scan command and returns the result as-is.
+     *
+     * This method sends the provided command input to DynamoDB and returns the items in the response.
+     * If a `startKey` is provided, it will be used as the `ExclusiveStartKey` to support pagination.
+     *
+     * Note: DynamoDB may return fewer items than the specified `Limit`, depending on the 1 MB size cap or internal filtering.
+     * This method does not perform deep pagination to fulfill the exact limit.
+     *
+     * @param commandInput - The DynamoDB QueryCommandInput or ScanCommandInput.
+     * @returns A partial item list of type `T`, along with the LastEvaluatedKey if more data is available.
+     */
+    private sendCommand;
+}

package/dist/repositories/base-db.repo.interface.d.ts

@@ -0,0 +1,61 @@
+import { BaseEntity, DynamoIndexMap } from "../index";
+import { CoreRepo } from "./base-core.repo.interface";
+export interface BaseRepoDB<T extends BaseEntity> extends CoreRepo<T> {
+    /**
+     * Executes a transactional write operation.
+     * This is typically supported by DynamoDB for atomic operations.
+     *
+     * @param operations - An array of write operations (create, update, delete) to perform atomically.
+     * @returns True if the transaction was successful; otherwise, false.
+     */
+    transactionWrite(operations: {
+        create?: {
+            tableName: string;
+            item: Record<string, any>;
+        }[];
+        update?: {
+            tableName: string;
+            key: {
+                id: string;
+            };
+            updateData: Record<string, any>;
+        }[];
+        delete?: {
+            tableName: string;
+            key: {
+                id: string;
+            };
+        }[];
+    }): Promise<boolean>;
+    /**
+     * Executes a transactional read operation.
+     * This is typically supported by DynamoDB for atomic read operations.
+     *
+     * @param operations - An array of read operations to perform atomically.
+     * @returns An array of results from the transaction.
+     */
+    transactionRead<T>(operations: {
+        id: string;
+        sortKey?: string;
+    }[]): Promise<T[]>;
+    /**
+     * (Optional) Executes a transactional write operation.
+     * This is typically only supported by DynamoDB.
+     *
+     * @param operations - An array of write operations to perform atomically.
+     * @returns True if the transaction was successful; otherwise, false.
+     */
+    transactWrite?(operations: any[]): Promise<boolean>;
+    /**
+     * (Optional) Executes a transactional read operation.
+     * This is typically only supported by DynamoDB.
+     *
+     * @param operations - An array of read operations to perform atomically.
+     * @returns An array of results from the transaction.
+     */
+    transactRead?<TResult = any>(operations: any[]): Promise<TResult[]>;
+    setIndexMap(value: DynamoIndexMap): boolean;
+    getIndexMap(): DynamoIndexMap;
+    setTableName(value: string): boolean;
+    getTableName(): string;
+}

package/dist/repositories/base-db.repo.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=base-db.repo.interface.js.map

package/dist/repositories/base-db.repo.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-db.repo.interface.js","sourceRoot":"","sources":["../../src/repositories/base-db.repo.interface.ts"],"names":[],"mappings":""}