cmp-aws-database 2.1.2-dev.4 → 2.1.2-dev.40

package/dist/customer-user/testing-session/testing-session-dao.js

@@ -0,0 +1,149 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testingSessionDao = void 0;
+const dynamoose_1 = __importDefault(require("dynamoose"));
+const base_dynamoose_dao_1 = require("../../base-dynamoose-dao");
+const testing_session_model_1 = require("./testing-session-model");
+/**
+ * DAO for tasting / testing session bookings.
+ *
+ * Table keys: `testingSessionId` (PK).
+ * Lookups:
+ * - `stageIndex` → all sessions by `stage`
+ * - `userIdIndex` → all sessions for a `userId`
+ * - `userIdStageIndex` → sessions for `userId` + `stage`
+ */
+class TestingSessionDao extends base_dynamoose_dao_1.GenericDynamooseDAO {
+    constructor() {
+        super(testing_session_model_1.TestingSessionModel, "testingSessionId");
+        /**
+         * Creates one testing session record.
+         *
+         * Use when: booking a new tasting/testing session.
+         * - `testingSessionId` auto-generates if omitted.
+         *
+         * @example
+         * await testingSessionDao.save({
+         *     userId: "user-123",
+         *     testingDate: "2026-06-20",
+         *     testingTime: "18:30",
+         *     visitDurationMinutes: 120,
+         *     venueAddress: "Hyderabad, Telangana",
+         *     locationUrl: "https://maps.google.com/...",
+         *     stage: "CONFIRMED",
+         *     preference: "VEG",
+         *     noOfGuestVisit: 4
+         * });
+         */
+        this.save = async (item, authContext) => {
+            return super.save(item, authContext);
+        };
+        /**
+         * Updates one testing session by `testingSessionId`.
+         *
+         * Use when: rescheduling, cancelling, or marking session as completed.
+         *
+         * @example
+         * await testingSessionDao.update("session-uuid", { stage: "COMPLETED" });
+         */
+        this.update = async (testingSessionId, updates, authContext) => {
+            const updated = await testing_session_model_1.TestingSessionModel.update({ testingSessionId }, {
+                ...updates,
+                updated_time: new Date(),
+                updated_user: authContext?.userSub
+            }, {
+                condition: new dynamoose_1.default.Condition().attribute("testingSessionId").exists()
+            });
+            return updated;
+        };
+        /**
+         * Fetches one testing session by primary key.
+         *
+         * @example
+         * const session = await testingSessionDao.getById("session-uuid");
+         */
+        this.getById = async (testingSessionId) => this.get(testingSessionId);
+        /**
+         * Lists testing sessions by `stage` (GSI `stageIndex`).
+         *
+         * @example
+         * const confirmed = await testingSessionDao.listByStage("CONFIRMED", 20);
+         */
+        this.listByStage = async (stage, limit, token) => {
+            const decodedToken = this.decode(token);
+            let queryBuilder = testing_session_model_1.TestingSessionModel.query("stage").eq(stage).using("stageIndex");
+            if (decodedToken) {
+                queryBuilder = queryBuilder.startAt(decodedToken);
+            }
+            if (typeof limit === "number") {
+                queryBuilder = queryBuilder.limit(limit);
+            }
+            const queryResult = await queryBuilder.exec();
+            return {
+                items: queryResult,
+                nextToken: await this.encode(queryResult.lastKey)
+            };
+        };
+        /**
+         * Lists all testing sessions for a user (GSI `userIdIndex`).
+         *
+         * Use when: user profile / my-sessions screen without stage filter.
+         *
+         * @example
+         * const sessions = await testingSessionDao.listByUserId("user-123", 20);
+         */
+        this.listByUserId = async (userId, limit, token) => {
+            const decodedToken = this.decode(token);
+            let queryBuilder = testing_session_model_1.TestingSessionModel.query("userId").eq(userId).using("userIdIndex");
+            if (decodedToken) {
+                queryBuilder = queryBuilder.startAt(decodedToken);
+            }
+            if (typeof limit === "number") {
+                queryBuilder = queryBuilder.limit(limit);
+            }
+            const queryResult = await queryBuilder.exec();
+            return {
+                items: queryResult,
+                nextToken: await this.encode(queryResult.lastKey)
+            };
+        };
+        /**
+         * Lists testing sessions for a user filtered by `stage` (GSI `userIdStageIndex`).
+         *
+         * Use when: showing only confirmed/cancelled/completed sessions for one user.
+         *
+         * @example
+         * const confirmed = await testingSessionDao.listByUserIdAndStage("user-123", "CONFIRMED", 20);
+         */
+        this.listByUserIdAndStage = async (userId, stage, limit, token) => {
+            const decodedToken = this.decode(token);
+            let queryBuilder = testing_session_model_1.TestingSessionModel.query("userId")
+                .eq(userId)
+                .where("stage")
+                .eq(stage)
+                .using("userIdStageIndex");
+            if (decodedToken) {
+                queryBuilder = queryBuilder.startAt(decodedToken);
+            }
+            if (typeof limit === "number") {
+                queryBuilder = queryBuilder.limit(limit);
+            }
+            const queryResult = await queryBuilder.exec();
+            return {
+                items: queryResult,
+                nextToken: await this.encode(queryResult.lastKey)
+            };
+        };
+        /**
+         * Deletes one testing session by primary key.
+         */
+        this.deleteById = async (testingSessionId) => {
+            await this.delete(testingSessionId);
+        };
+    }
+}
+exports.testingSessionDao = new TestingSessionDao();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"testing-session-dao.js","sourceRoot":"","sources":["../../../src/customer-user/testing-session/testing-session-dao.ts"],"names":[],"mappings":"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","sourcesContent":["import dynamoose from \"dynamoose\";\nimport { DynamoKey, GenericDynamooseDAO } from \"../../base-dynamoose-dao\";\nimport { AuthContext } from \"../../base-dynamoose-model\";\nimport {\n    CreateTestingSessionInput,\n    TestingSession,\n    TestingSessionModel,\n    TestingSessionStage\n} from \"./testing-session-model\";\n\ntype ListResult = {\n    items: TestingSession[];\n    nextToken?: string;\n};\n\n/**\n * DAO for tasting / testing session bookings.\n *\n * Table keys: `testingSessionId` (PK).\n * Lookups:\n * - `stageIndex` → all sessions by `stage`\n * - `userIdIndex` → all sessions for a `userId`\n * - `userIdStageIndex` → sessions for `userId` + `stage`\n */\nclass TestingSessionDao extends GenericDynamooseDAO<TestingSession> {\n    constructor() {\n        super(TestingSessionModel, \"testingSessionId\");\n    }\n\n    /**\n     * Creates one testing session record.\n     *\n     * Use when: booking a new tasting/testing session.\n     * - `testingSessionId` auto-generates if omitted.\n     *\n     * @example\n     * await testingSessionDao.save({\n     *     userId: \"user-123\",\n     *     testingDate: \"2026-06-20\",\n     *     testingTime: \"18:30\",\n     *     visitDurationMinutes: 120,\n     *     venueAddress: \"Hyderabad, Telangana\",\n     *     locationUrl: \"https://maps.google.com/...\",\n     *     stage: \"CONFIRMED\",\n     *     preference: \"VEG\",\n     *     noOfGuestVisit: 4\n     * });\n     */\n    save = async (item: CreateTestingSessionInput, authContext?: AuthContext): Promise<TestingSession> => {\n        return super.save(item as TestingSession, authContext);\n    };\n\n    /**\n     * Updates one testing session by `testingSessionId`.\n     *\n     * Use when: rescheduling, cancelling, or marking session as completed.\n     *\n     * @example\n     * await testingSessionDao.update(\"session-uuid\", { stage: \"COMPLETED\" });\n     */\n    update = async (\n        testingSessionId: string,\n        updates: Partial<TestingSession>,\n        authContext?: AuthContext\n    ): Promise<TestingSession> => {\n        const updated = await TestingSessionModel.update(\n            { testingSessionId },\n            {\n                ...updates,\n                updated_time: new Date(),\n                updated_user: authContext?.userSub\n            },\n            {\n                condition: new dynamoose.Condition().attribute(\"testingSessionId\").exists()\n            }\n        );\n        return updated as unknown as TestingSession;\n    };\n\n    /**\n     * Fetches one testing session by primary key.\n     *\n     * @example\n     * const session = await testingSessionDao.getById(\"session-uuid\");\n     */\n    getById = async (testingSessionId: string): Promise<TestingSession | null> =>\n        this.get(testingSessionId);\n\n    /**\n     * Lists testing sessions by `stage` (GSI `stageIndex`).\n     *\n     * @example\n     * const confirmed = await testingSessionDao.listByStage(\"CONFIRMED\", 20);\n     */\n    listByStage = async (\n        stage: TestingSessionStage,\n        limit?: number,\n        token?: string\n    ): Promise<ListResult> => {\n        const decodedToken = this.decode(token);\n        let queryBuilder = TestingSessionModel.query(\"stage\").eq(stage).using(\"stageIndex\");\n        if (decodedToken) {\n            queryBuilder = queryBuilder.startAt(decodedToken);\n        }\n        if (typeof limit === \"number\") {\n            queryBuilder = queryBuilder.limit(limit);\n        }\n        const queryResult = await queryBuilder.exec();\n        return {\n            items: queryResult as unknown as TestingSession[],\n            nextToken: await this.encode(queryResult.lastKey as DynamoKey | undefined)\n        };\n    };\n\n    /**\n     * Lists all testing sessions for a user (GSI `userIdIndex`).\n     *\n     * Use when: user profile / my-sessions screen without stage filter.\n     *\n     * @example\n     * const sessions = await testingSessionDao.listByUserId(\"user-123\", 20);\n     */\n    listByUserId = async (userId: string, limit?: number, token?: string): Promise<ListResult> => {\n        const decodedToken = this.decode(token);\n        let queryBuilder = TestingSessionModel.query(\"userId\").eq(userId).using(\"userIdIndex\");\n        if (decodedToken) {\n            queryBuilder = queryBuilder.startAt(decodedToken);\n        }\n        if (typeof limit === \"number\") {\n            queryBuilder = queryBuilder.limit(limit);\n        }\n        const queryResult = await queryBuilder.exec();\n        return {\n            items: queryResult as unknown as TestingSession[],\n            nextToken: await this.encode(queryResult.lastKey as DynamoKey | undefined)\n        };\n    };\n\n    /**\n     * Lists testing sessions for a user filtered by `stage` (GSI `userIdStageIndex`).\n     *\n     * Use when: showing only confirmed/cancelled/completed sessions for one user.\n     *\n     * @example\n     * const confirmed = await testingSessionDao.listByUserIdAndStage(\"user-123\", \"CONFIRMED\", 20);\n     */\n    listByUserIdAndStage = async (\n        userId: string,\n        stage: TestingSessionStage,\n        limit?: number,\n        token?: string\n    ): Promise<ListResult> => {\n        const decodedToken = this.decode(token);\n        let queryBuilder = TestingSessionModel.query(\"userId\")\n            .eq(userId)\n            .where(\"stage\")\n            .eq(stage)\n            .using(\"userIdStageIndex\");\n        if (decodedToken) {\n            queryBuilder = queryBuilder.startAt(decodedToken);\n        }\n        if (typeof limit === \"number\") {\n            queryBuilder = queryBuilder.limit(limit);\n        }\n        const queryResult = await queryBuilder.exec();\n        return {\n            items: queryResult as unknown as TestingSession[],\n            nextToken: await this.encode(queryResult.lastKey as DynamoKey | undefined)\n        };\n    };\n\n    /**\n     * Deletes one testing session by primary key.\n     */\n    deleteById = async (testingSessionId: string): Promise<void> => {\n        await this.delete(testingSessionId);\n    };\n}\n\nexport const testingSessionDao = new TestingSessionDao();\n"]}

package/dist/customer-user/testing-session/testing-session-model.d.ts

@@ -0,0 +1,30 @@
+import { BaseDynamooseModel } from "../../base-dynamoose-model";
+export declare const TESTING_SESSION_STAGE: {
+    readonly CONFIRMED: "CONFIRMED";
+    readonly CANCELLED: "CANCELLED";
+    readonly RESCHEDULED: "RESCHEDULED";
+    readonly COMPLETED: "COMPLETED";
+};
+export type TestingSessionStage = (typeof TESTING_SESSION_STAGE)[keyof typeof TESTING_SESSION_STAGE];
+export declare const TESTING_SESSION_PREFERENCE: {
+    readonly VEG: "VEG";
+    readonly NONVEG: "NONVEG";
+};
+export type TestingSessionPreference = (typeof TESTING_SESSION_PREFERENCE)[keyof typeof TESTING_SESSION_PREFERENCE];
+export interface TestingSession extends BaseDynamooseModel {
+    testingSessionId: string;
+    testingDate: string;
+    testingTime: string;
+    visitDurationMinutes: number;
+    venueAddress: string;
+    locationUrl: string;
+    stage: TestingSessionStage;
+    preference: TestingSessionPreference;
+    noOfGuestVisit: number;
+    userId: string;
+}
+export type CreateTestingSessionInput = Omit<TestingSession, "testingSessionId"> & {
+    testingSessionId?: string;
+};
+export declare const TestingSessionModel: import("dynamoose/dist/General").ModelType<TestingSession>;
+export declare const convertToTestingSessionModel: (input: CreateTestingSessionInput | TestingSession) => TestingSession;

package/dist/customer-user/testing-session/testing-session-model.js

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToTestingSessionModel = exports.TestingSessionModel = exports.TESTING_SESSION_PREFERENCE = exports.TESTING_SESSION_STAGE = void 0;
+const dynamoose_1 = __importDefault(require("dynamoose"));
+const crypto_1 = require("crypto");
+const base_dynamoose_model_1 = require("../../base-dynamoose-model");
+const table_names_1 = require("../../config/table-names");
+exports.TESTING_SESSION_STAGE = {
+    CONFIRMED: "CONFIRMED",
+    CANCELLED: "CANCELLED",
+    RESCHEDULED: "RESCHEDULED",
+    COMPLETED: "COMPLETED"
+};
+exports.TESTING_SESSION_PREFERENCE = {
+    VEG: "VEG",
+    NONVEG: "NONVEG"
+};
+const testingSessionSchema = new dynamoose_1.default.Schema({
+    testingSessionId: {
+        type: String,
+        hashKey: true,
+        required: true,
+        default: () => (0, crypto_1.randomUUID)()
+    },
+    testingDate: {
+        type: String,
+        required: true
+    },
+    testingTime: {
+        type: String,
+        required: true
+    },
+    visitDurationMinutes: {
+        type: Number,
+        required: true
+    },
+    venueAddress: {
+        type: String,
+        required: true
+    },
+    locationUrl: {
+        type: String,
+        required: true
+    },
+    stage: {
+        type: String,
+        required: true,
+        enum: [
+            exports.TESTING_SESSION_STAGE.CONFIRMED,
+            exports.TESTING_SESSION_STAGE.CANCELLED,
+            exports.TESTING_SESSION_STAGE.RESCHEDULED,
+            exports.TESTING_SESSION_STAGE.COMPLETED
+        ],
+        index: {
+            name: "stageIndex",
+            type: "global"
+        }
+    },
+    preference: {
+        type: String,
+        required: true,
+        enum: [exports.TESTING_SESSION_PREFERENCE.VEG, exports.TESTING_SESSION_PREFERENCE.NONVEG]
+    },
+    noOfGuestVisit: {
+        type: Number,
+        required: true
+    },
+    userId: {
+        type: String,
+        required: true,
+        index: [
+            {
+                name: "userIdIndex",
+                type: "global"
+            },
+            {
+                name: "userIdStageIndex",
+                type: "global",
+                rangeKey: "stage"
+            }
+        ]
+    },
+    eventGuestCount: {
+        type: Number,
+        required: false
+    },
+    occasion: {
+        type: String,
+        required: false
+    },
+    ...base_dynamoose_model_1.BASE_DYNAMOOSE_AUDIT_SCHEMA
+}, {
+    saveUnknown: false,
+    timestamps: true
+});
+exports.TestingSessionModel = dynamoose_1.default.model(table_names_1.TABLE_NAMES.TESTING_SESSION, testingSessionSchema, { create: false, waitForActive: false });
+const convertToTestingSessionModel = (input) => {
+    return new exports.TestingSessionModel(input);
+};
+exports.convertToTestingSessionModel = convertToTestingSessionModel;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/patner-third-party/third-party-api-key/third-party-api-key-dao.d.ts

@@ -0,0 +1,114 @@
+import { GenericDynamooseDAO } from "../../base-dynamoose-dao";
+import { AuthContext } from "../../base-dynamoose-model";
+import { CreateThirdPartyApiKeyInput, ThirdPartyApiKey, ThirdPartyApiKeyStatus } from "./third-party-api-key-model";
+type ListResult = {
+    items: ThirdPartyApiKey[];
+    nextToken?: string;
+};
+/**
+ * Thrown when the same `apiKeyHash` already exists in the table.
+ * Use this to return a clean duplicate-key error from admin/create-key APIs.
+ */
+export declare class DuplicateApiKeyHashError extends Error {
+    constructor(apiKeyHash: string);
+}
+/**
+ * DAO for permanent third-party API keys (Method 2).
+ *
+ * Table keys: `partnerId` (PK) + `apiKeyId` (SK).
+ * Auth lookup: hash incoming key, then use `getActiveByApiKeyHash`.
+ */
+declare class ThirdPartyApiKeyDao extends GenericDynamooseDAO<ThirdPartyApiKey> {
+    constructor();
+    /**
+     * Creates a new permanent API key record for a partner.
+     *
+     * Use when: admin/onboarding flow issues a new API key to a third-party partner.
+     * - `apiKeyId` auto-generates if omitted.
+     * - Pass only `apiKeyHash` (SHA-256 etc.), never the raw key.
+     * - Default status is `ACTIVE`.
+     * - Throws `DuplicateApiKeyHashError` if hash already exists.
+     */
+    save: (item: CreateThirdPartyApiKeyInput, authContext?: AuthContext) => Promise<ThirdPartyApiKey>;
+    /**
+     * Updates an existing API key by `partnerId` + `apiKeyId`.
+     *
+     * Use when: changing key metadata or rotating hash/status from admin tools.
+     * - Fails if the record does not exist.
+     * - Rejects duplicate `apiKeyHash` belonging to another key.
+     * - Stamps `updated_time` / `updated_user` automatically.
+     */
+    updateApiKey: (partnerId: string, apiKeyId: string, updates: Partial<ThirdPartyApiKey>, authContext?: AuthContext) => Promise<ThirdPartyApiKey>;
+    /**
+     * Fetches one API key by table primary key (`partnerId` + `apiKeyId`).
+     *
+     * Use when: admin detail page, key management screen, or internal ops lookup
+     * when both partner id and key id are already known.
+     */
+    getByPartnerAndApiKeyId: (partnerId: string, apiKeyId: string) => Promise<ThirdPartyApiKey | null>;
+    /**
+     * Lists all API keys for a partner (query on PK `partnerId`).
+     *
+     * Use when: partner dashboard showing every issued key (active + inactive).
+     * Supports pagination via `limit` and `token`.
+     */
+    listByPartnerId: (partnerId: string, limit?: number, token?: string) => Promise<ListResult>;
+    /**
+     * Lists partner keys filtered by `status` (`ACTIVE` or `INACTIVE`).
+     *
+     * Use when: showing only active keys in UI, or auditing disabled/revoked keys
+     * for one partner without scanning the whole table.
+     */
+    listByPartnerIdAndStatus: (partnerId: string, status: ThirdPartyApiKeyStatus, limit?: number, token?: string) => Promise<ListResult>;
+    /**
+     * Finds a key by `apiKeyHash` using GSI `apiKeyHashIndex`.
+     *
+     * Use when: you need the record regardless of status (admin/debug),
+     * or before deciding whether to allow auth.
+     * Returns `null` if no key matches the hash.
+     */
+    getByApiKeyHash: (apiKeyHash: string) => Promise<ThirdPartyApiKey | null>;
+    /**
+     * Validates an incoming API request key (auth middleware use-case).
+     *
+     * Use when: request header/bearer token is hashed and you must allow access
+     * only if the key exists AND `status === ACTIVE` AND not past `expiresAt`.
+     * Returns `null` for missing, inactive, revoked, or expired keys.
+     */
+    getActiveByApiKeyHash: (apiKeyHash: string) => Promise<ThirdPartyApiKey | null>;
+    /**
+     * Records when an API key was last used (audit / monitoring).
+     *
+     * Use when: auth middleware successfully validates a key and you want usage telemetry.
+     */
+    touchLastUsedAt: (partnerId: string, apiKeyId: string) => Promise<void>;
+    /**
+     * Paginated query on GSI `apiKeyHashIndex`.
+     *
+     * Use when: low-level lookup by hash with pagination.
+     * Normally prefer `getByApiKeyHash` for single-record auth/admin flows.
+     */
+    listByApiKeyHash: (apiKeyHash: string, limit?: number, token?: string) => Promise<ListResult>;
+    /**
+     * Lists keys across all partners by `status` (GSI `statusIndex`).
+     *
+     * Use when: global admin reports — e.g. all active keys, or cleanup job
+     * for all inactive/revoked keys.
+     */
+    listByStatus: (status: ThirdPartyApiKeyStatus, limit?: number, token?: string) => Promise<ListResult>;
+    /**
+     * Disables an API key without deleting it (`status` → `INACTIVE`).
+     *
+     * Use when: partner offboarding, key compromise, or temporary suspension.
+     * Disabled keys fail `getActiveByApiKeyHash` immediately.
+     */
+    deactivate: (partnerId: string, apiKeyId: string, authContext?: AuthContext) => Promise<ThirdPartyApiKey>;
+    /**
+     * Re-enables a previously disabled key (`status` → `ACTIVE`).
+     *
+     * Use when: restoring partner access after suspension without issuing a new key.
+     */
+    activate: (partnerId: string, apiKeyId: string, authContext?: AuthContext) => Promise<ThirdPartyApiKey>;
+}
+export declare const thirdPartyApiKeyDao: ThirdPartyApiKeyDao;
+export {};