cmp-aws-database 2.1.2-dev.10 → 2.1.2-dev.11

package/dist/config/table-names.d.ts

@@ -20,6 +20,7 @@ export declare const BASE_TABLE_NAMES: {
     readonly INFLUENCER_PROMO: "InfluencerPromoTable";
     readonly INFLUENCER_REFERRAL: "InfluencerReferralTable";
     readonly CATALOGUE_ITEMS: "CatalogueItemsTable";
+    readonly THIRD_PARTY_API_KEY: "ThirdPartyApiKeyTable";
     readonly ORDER: "OrderTable";
     readonly ORDER_ADDRESS: "OrderAddressTable";
     readonly ORDER_REVIEW: "OrderReviewTable";
@@ -79,6 +80,7 @@ export declare const TABLE_NAMES: {
     readonly INFLUENCER_PROMO: string;
     readonly INFLUENCER_REFERRAL: string;
     readonly CATALOGUE_ITEMS: string;
+    readonly THIRD_PARTY_API_KEY: string;
     readonly ORDER: string;
     readonly ORDER_ADDRESS: string;
     readonly ORDER_REVIEW: string;

package/dist/config/table-names.js

@@ -26,6 +26,7 @@ exports.BASE_TABLE_NAMES = {
     INFLUENCER_PROMO: 'InfluencerPromoTable',
     INFLUENCER_REFERRAL: 'InfluencerReferralTable',
     CATALOGUE_ITEMS: 'CatalogueItemsTable',
+    THIRD_PARTY_API_KEY: 'ThirdPartyApiKeyTable',
     // Order Module Tables
     ORDER: 'OrderTable',
     ORDER_ADDRESS: 'OrderAddressTable',
@@ -100,6 +101,7 @@ exports.TABLE_NAMES = {
     INFLUENCER_PROMO: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.INFLUENCER_PROMO),
     INFLUENCER_REFERRAL: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.INFLUENCER_REFERRAL),
     CATALOGUE_ITEMS: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.CATALOGUE_ITEMS),
+    THIRD_PARTY_API_KEY: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.THIRD_PARTY_API_KEY),
     // Order Module Tables
     ORDER: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.ORDER),
     ORDER_ADDRESS: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.ORDER_ADDRESS),
@@ -136,4 +138,4 @@ exports.TABLE_NAMES = {
     ACTIVITY_LOGS: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.ACTIVITY_LOGS),
     QUOTATIONS: TableNameManager.getTableName(exports.BASE_TABLE_NAMES.QUOTATIONS),
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-names.js","sourceRoot":"","sources":["../../src/config/table-names.ts"],"names":[],"mappings":"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","sourcesContent":["import { DatabaseFactory } from './database-factory';\n\n// Base table names (without environment prefix)\nexport const BASE_TABLE_NAMES = {\n    // Customer App Tables\n    APP_FEEDBACK: 'AppFeedbackTable',\n    LSQ_CRM: 'LsqCrmTable',\n    CUTLERY: 'CutleryTable',\n    ITEM_ACCOMPANIMENTS: 'ItemAccompanimentsTable',\n    CUISINE: 'CuisineTable',\n    TIER_DETAILS: 'TierDetailsTable',\n    USER_ORDER_SUMMARY: 'UserOrderSummaryTable',\n    TIER_REFERRAL: 'TierReferralTable',\n    USER_ADDRESS_REQUEST: 'UserAddressRequestTable',\n    COMMON_FEEDBACK: 'CommonFeedbackTable',\n    GUEST_FEEDBACK: 'GuestFeedbackTable',\n    COUNTER: 'CounterTable',\n    REQUEST_INVOICE: 'RequestInvoiceTable',\n    PLATTER_SEARCH_EVENTS: 'PlatterSearchEventsTable',\n    ORDER_REVIEW_FEEDBACK: 'OrderReviewFeedbackTable',\n    CATERING_REQUEST: 'CateringRequestTable',\n    FMP_REQUEST_CALLBACK: 'FmpRequestCallbackTable',\n    PLATTER_FIT: 'PlatterFitTable',\n    INFLUENCER_PROMO: 'InfluencerPromoTable',\n    INFLUENCER_REFERRAL: 'InfluencerReferralTable',\n    CATALOGUE_ITEMS: 'CatalogueItemsTable',\n\n    // Order Module Tables\n    ORDER: 'OrderTable',\n    ORDER_ADDRESS: 'OrderAddressTable',\n    ORDER_REVIEW: 'OrderReviewTable',\n    PAYMENT: 'PaymentTable',\n    PLATE_ORDER: 'PlateOrderTable',\n    TRACKING: 'TrackingTable',\n    USER_ADDRESS: 'UserAddressTable',\n    USER_SPECIFICS: 'UserSpecificsTable',\n    BBQ_SKEWERS: 'BbqSkewersTable',\n\n    // Other Customer Tables\n    ADD_ONS: 'AddOnsTable',\n    BANK_DETAILS: 'BankDetailsTable',\n    CART: 'CartTable',\n    CART_CATEGORIES: 'CartCategoriesTable',\n    CATEGORY: 'CategoryTable',\n    CATERING: 'CateringTable',\n    CONTENT: 'ContentTable',\n    COUPONS: 'CouponsTable',\n    DEFAULT_PLATTER: 'DefaultPlatterTable',\n    DEFAULT_PLATTER_CATEGORIES: 'DefaultPlatterCategoriesTable',\n    DEFAULT_PLATTER_ITEMS: 'DefaultPlatterItemsTable',\n    EVENT_EXECUTIVES: 'EventExecutivesTable',\n    ITEMS: 'ItemsTable',\n    LEAD: 'LeadTable',\n    OCCASION: 'OccasionTable',\n    REFERRAL_CONTENT: 'ReferralContentTable',\n    USER: 'UserTable',\n    WALLET: 'WalletTable',\n    WALLET_TRANSACTION: 'WalletTransactionTable',\n    WITHDRAWN: 'WithdrawnTable',\n\n    // Internal User Tables\n    INTERNAL_USER: 'InternalUserTable',\n    ACTIVITY_LOGS: 'ActivityLogsTable',\n    QUOTATIONS: 'QuotationsTable',\n} as const;\n\n// Environment-aware table name getter\nexport class TableNameManager {\n    public static getTableName(baseTableName: string): string {\n        return DatabaseFactory.getTableName(baseTableName);\n    }\n\n    public static getAllTableNames(): Record<string, string> {\n        const tableNames: Record<string, string> = {};\n\n        Object.entries(BASE_TABLE_NAMES).forEach(([key, value]) => {\n            tableNames[key] = this.getTableName(value);\n        });\n\n        return tableNames;\n    }\n}\n\n// Export environment-aware table names\nexport const TABLE_NAMES = {\n    // Customer App Tables\n    APP_FEEDBACK: TableNameManager.getTableName(BASE_TABLE_NAMES.APP_FEEDBACK),\n    LSQ_CRM: TableNameManager.getTableName(BASE_TABLE_NAMES.LSQ_CRM),\n    CUTLERY: TableNameManager.getTableName(BASE_TABLE_NAMES.CUTLERY),\n    ITEM_ACCOMPANIMENTS: TableNameManager.getTableName(BASE_TABLE_NAMES.ITEM_ACCOMPANIMENTS),\n    CUISINE: TableNameManager.getTableName(BASE_TABLE_NAMES.CUISINE),\n    TIER_DETAILS: TableNameManager.getTableName(BASE_TABLE_NAMES.TIER_DETAILS),\n    USER_ORDER_SUMMARY: TableNameManager.getTableName(BASE_TABLE_NAMES.USER_ORDER_SUMMARY),\n    TIER_REFERRAL: TableNameManager.getTableName(BASE_TABLE_NAMES.TIER_REFERRAL),\n    USER_ADDRESS_REQUEST: TableNameManager.getTableName(BASE_TABLE_NAMES.USER_ADDRESS_REQUEST),\n    COMMON_FEEDBACK: TableNameManager.getTableName(BASE_TABLE_NAMES.COMMON_FEEDBACK),\n    GUEST_FEEDBACK: TableNameManager.getTableName(BASE_TABLE_NAMES.GUEST_FEEDBACK),\n    COUNTER: TableNameManager.getTableName(BASE_TABLE_NAMES.COUNTER),\n    REQUEST_INVOICE: TableNameManager.getTableName(BASE_TABLE_NAMES.REQUEST_INVOICE),\n    PLATTER_SEARCH_EVENTS: TableNameManager.getTableName(BASE_TABLE_NAMES.PLATTER_SEARCH_EVENTS),\n    ORDER_REVIEW_FEEDBACK: TableNameManager.getTableName(BASE_TABLE_NAMES.ORDER_REVIEW_FEEDBACK),\n    CATERING_REQUEST: TableNameManager.getTableName(BASE_TABLE_NAMES.CATERING_REQUEST),\n    FMP_REQUEST_CALLBACK: TableNameManager.getTableName(BASE_TABLE_NAMES.FMP_REQUEST_CALLBACK),\n    PLATTER_FIT: TableNameManager.getTableName(BASE_TABLE_NAMES.PLATTER_FIT),\n    INFLUENCER_PROMO: TableNameManager.getTableName(BASE_TABLE_NAMES.INFLUENCER_PROMO),\n    INFLUENCER_REFERRAL: TableNameManager.getTableName(BASE_TABLE_NAMES.INFLUENCER_REFERRAL),\n    CATALOGUE_ITEMS: TableNameManager.getTableName(BASE_TABLE_NAMES.CATALOGUE_ITEMS),\n\n    // Order Module Tables\n    ORDER: TableNameManager.getTableName(BASE_TABLE_NAMES.ORDER),\n    ORDER_ADDRESS: TableNameManager.getTableName(BASE_TABLE_NAMES.ORDER_ADDRESS),\n    ORDER_REVIEW: TableNameManager.getTableName(BASE_TABLE_NAMES.ORDER_REVIEW),\n    PAYMENT: TableNameManager.getTableName(BASE_TABLE_NAMES.PAYMENT),\n    PLATE_ORDER: TableNameManager.getTableName(BASE_TABLE_NAMES.PLATE_ORDER),\n    TRACKING: TableNameManager.getTableName(BASE_TABLE_NAMES.TRACKING),\n    USER_ADDRESS: TableNameManager.getTableName(BASE_TABLE_NAMES.USER_ADDRESS),\n    USER_SPECIFICS: TableNameManager.getTableName(BASE_TABLE_NAMES.USER_SPECIFICS),\n    BBQ_SKEWERS: TableNameManager.getTableName(BASE_TABLE_NAMES.BBQ_SKEWERS),\n\n    // Other Customer Tables\n    ADD_ONS: TableNameManager.getTableName(BASE_TABLE_NAMES.ADD_ONS),\n    BANK_DETAILS: TableNameManager.getTableName(BASE_TABLE_NAMES.BANK_DETAILS),\n    CART: TableNameManager.getTableName(BASE_TABLE_NAMES.CART),\n    CART_CATEGORIES: TableNameManager.getTableName(BASE_TABLE_NAMES.CART_CATEGORIES),\n    CATEGORY: TableNameManager.getTableName(BASE_TABLE_NAMES.CATEGORY),\n    CATERING: TableNameManager.getTableName(BASE_TABLE_NAMES.CATERING),\n    CONTENT: TableNameManager.getTableName(BASE_TABLE_NAMES.CONTENT),\n    COUPONS: TableNameManager.getTableName(BASE_TABLE_NAMES.COUPONS),\n    DEFAULT_PLATTER: TableNameManager.getTableName(BASE_TABLE_NAMES.DEFAULT_PLATTER),\n    DEFAULT_PLATTER_CATEGORIES: TableNameManager.getTableName(BASE_TABLE_NAMES.DEFAULT_PLATTER_CATEGORIES),\n    DEFAULT_PLATTER_ITEMS: TableNameManager.getTableName(BASE_TABLE_NAMES.DEFAULT_PLATTER_ITEMS),\n    EVENT_EXECUTIVES: TableNameManager.getTableName(BASE_TABLE_NAMES.EVENT_EXECUTIVES),\n    ITEMS: TableNameManager.getTableName(BASE_TABLE_NAMES.ITEMS),\n    LEAD: TableNameManager.getTableName(BASE_TABLE_NAMES.LEAD),\n    OCCASION: TableNameManager.getTableName(BASE_TABLE_NAMES.OCCASION),\n    REFERRAL_CONTENT: TableNameManager.getTableName(BASE_TABLE_NAMES.REFERRAL_CONTENT),\n    USER: TableNameManager.getTableName(BASE_TABLE_NAMES.USER),\n    WALLET: TableNameManager.getTableName(BASE_TABLE_NAMES.WALLET),\n    WALLET_TRANSACTION: TableNameManager.getTableName(BASE_TABLE_NAMES.WALLET_TRANSACTION),\n    WITHDRAWN: TableNameManager.getTableName(BASE_TABLE_NAMES.WITHDRAWN),\n\n    // Internal User Tables\n    INTERNAL_USER: TableNameManager.getTableName(BASE_TABLE_NAMES.INTERNAL_USER),\n    ACTIVITY_LOGS: TableNameManager.getTableName(BASE_TABLE_NAMES.ACTIVITY_LOGS),\n    QUOTATIONS: TableNameManager.getTableName(BASE_TABLE_NAMES.QUOTATIONS),\n} as const;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-names.js","sourceRoot":"","sources":["../../src/config/table-names.ts"],"names":[],"mappings":"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","sourcesContent":["import { DatabaseFactory } from './database-factory';\n\n// Base table names (without environment prefix)\nexport const BASE_TABLE_NAMES = {\n    // Customer App Tables\n    APP_FEEDBACK: 'AppFeedbackTable',\n    LSQ_CRM: 'LsqCrmTable',\n    CUTLERY: 'CutleryTable',\n    ITEM_ACCOMPANIMENTS: 'ItemAccompanimentsTable',\n    CUISINE: 'CuisineTable',\n    TIER_DETAILS: 'TierDetailsTable',\n    USER_ORDER_SUMMARY: 'UserOrderSummaryTable',\n    TIER_REFERRAL: 'TierReferralTable',\n    USER_ADDRESS_REQUEST: 'UserAddressRequestTable',\n    COMMON_FEEDBACK: 'CommonFeedbackTable',\n    GUEST_FEEDBACK: 'GuestFeedbackTable',\n    COUNTER: 'CounterTable',\n    REQUEST_INVOICE: 'RequestInvoiceTable',\n    PLATTER_SEARCH_EVENTS: 'PlatterSearchEventsTable',\n    ORDER_REVIEW_FEEDBACK: 'OrderReviewFeedbackTable',\n    CATERING_REQUEST: 'CateringRequestTable',\n    FMP_REQUEST_CALLBACK: 'FmpRequestCallbackTable',\n    PLATTER_FIT: 'PlatterFitTable',\n    INFLUENCER_PROMO: 'InfluencerPromoTable',\n    INFLUENCER_REFERRAL: 'InfluencerReferralTable',\n    CATALOGUE_ITEMS: 'CatalogueItemsTable',\n    THIRD_PARTY_API_KEY: 'ThirdPartyApiKeyTable',\n\n    // Order Module Tables\n    ORDER: 'OrderTable',\n    ORDER_ADDRESS: 'OrderAddressTable',\n    ORDER_REVIEW: 'OrderReviewTable',\n    PAYMENT: 'PaymentTable',\n    PLATE_ORDER: 'PlateOrderTable',\n    TRACKING: 'TrackingTable',\n    USER_ADDRESS: 'UserAddressTable',\n    USER_SPECIFICS: 'UserSpecificsTable',\n    BBQ_SKEWERS: 'BbqSkewersTable',\n\n    // Other Customer Tables\n    ADD_ONS: 'AddOnsTable',\n    BANK_DETAILS: 'BankDetailsTable',\n    CART: 'CartTable',\n    CART_CATEGORIES: 'CartCategoriesTable',\n    CATEGORY: 'CategoryTable',\n    CATERING: 'CateringTable',\n    CONTENT: 'ContentTable',\n    COUPONS: 'CouponsTable',\n    DEFAULT_PLATTER: 'DefaultPlatterTable',\n    DEFAULT_PLATTER_CATEGORIES: 'DefaultPlatterCategoriesTable',\n    DEFAULT_PLATTER_ITEMS: 'DefaultPlatterItemsTable',\n    EVENT_EXECUTIVES: 'EventExecutivesTable',\n    ITEMS: 'ItemsTable',\n    LEAD: 'LeadTable',\n    OCCASION: 'OccasionTable',\n    REFERRAL_CONTENT: 'ReferralContentTable',\n    USER: 'UserTable',\n    WALLET: 'WalletTable',\n    WALLET_TRANSACTION: 'WalletTransactionTable',\n    WITHDRAWN: 'WithdrawnTable',\n\n    // Internal User Tables\n    INTERNAL_USER: 'InternalUserTable',\n    ACTIVITY_LOGS: 'ActivityLogsTable',\n    QUOTATIONS: 'QuotationsTable',\n} as const;\n\n// Environment-aware table name getter\nexport class TableNameManager {\n    public static getTableName(baseTableName: string): string {\n        return DatabaseFactory.getTableName(baseTableName);\n    }\n\n    public static getAllTableNames(): Record<string, string> {\n        const tableNames: Record<string, string> = {};\n\n        Object.entries(BASE_TABLE_NAMES).forEach(([key, value]) => {\n            tableNames[key] = this.getTableName(value);\n        });\n\n        return tableNames;\n    }\n}\n\n// Export environment-aware table names\nexport const TABLE_NAMES = {\n    // Customer App Tables\n    APP_FEEDBACK: TableNameManager.getTableName(BASE_TABLE_NAMES.APP_FEEDBACK),\n    LSQ_CRM: TableNameManager.getTableName(BASE_TABLE_NAMES.LSQ_CRM),\n    CUTLERY: TableNameManager.getTableName(BASE_TABLE_NAMES.CUTLERY),\n    ITEM_ACCOMPANIMENTS: TableNameManager.getTableName(BASE_TABLE_NAMES.ITEM_ACCOMPANIMENTS),\n    CUISINE: TableNameManager.getTableName(BASE_TABLE_NAMES.CUISINE),\n    TIER_DETAILS: TableNameManager.getTableName(BASE_TABLE_NAMES.TIER_DETAILS),\n    USER_ORDER_SUMMARY: TableNameManager.getTableName(BASE_TABLE_NAMES.USER_ORDER_SUMMARY),\n    TIER_REFERRAL: TableNameManager.getTableName(BASE_TABLE_NAMES.TIER_REFERRAL),\n    USER_ADDRESS_REQUEST: TableNameManager.getTableName(BASE_TABLE_NAMES.USER_ADDRESS_REQUEST),\n    COMMON_FEEDBACK: TableNameManager.getTableName(BASE_TABLE_NAMES.COMMON_FEEDBACK),\n    GUEST_FEEDBACK: TableNameManager.getTableName(BASE_TABLE_NAMES.GUEST_FEEDBACK),\n    COUNTER: TableNameManager.getTableName(BASE_TABLE_NAMES.COUNTER),\n    REQUEST_INVOICE: TableNameManager.getTableName(BASE_TABLE_NAMES.REQUEST_INVOICE),\n    PLATTER_SEARCH_EVENTS: TableNameManager.getTableName(BASE_TABLE_NAMES.PLATTER_SEARCH_EVENTS),\n    ORDER_REVIEW_FEEDBACK: TableNameManager.getTableName(BASE_TABLE_NAMES.ORDER_REVIEW_FEEDBACK),\n    CATERING_REQUEST: TableNameManager.getTableName(BASE_TABLE_NAMES.CATERING_REQUEST),\n    FMP_REQUEST_CALLBACK: TableNameManager.getTableName(BASE_TABLE_NAMES.FMP_REQUEST_CALLBACK),\n    PLATTER_FIT: TableNameManager.getTableName(BASE_TABLE_NAMES.PLATTER_FIT),\n    INFLUENCER_PROMO: TableNameManager.getTableName(BASE_TABLE_NAMES.INFLUENCER_PROMO),\n    INFLUENCER_REFERRAL: TableNameManager.getTableName(BASE_TABLE_NAMES.INFLUENCER_REFERRAL),\n    CATALOGUE_ITEMS: TableNameManager.getTableName(BASE_TABLE_NAMES.CATALOGUE_ITEMS),\n    THIRD_PARTY_API_KEY: TableNameManager.getTableName(BASE_TABLE_NAMES.THIRD_PARTY_API_KEY),\n\n    // Order Module Tables\n    ORDER: TableNameManager.getTableName(BASE_TABLE_NAMES.ORDER),\n    ORDER_ADDRESS: TableNameManager.getTableName(BASE_TABLE_NAMES.ORDER_ADDRESS),\n    ORDER_REVIEW: TableNameManager.getTableName(BASE_TABLE_NAMES.ORDER_REVIEW),\n    PAYMENT: TableNameManager.getTableName(BASE_TABLE_NAMES.PAYMENT),\n    PLATE_ORDER: TableNameManager.getTableName(BASE_TABLE_NAMES.PLATE_ORDER),\n    TRACKING: TableNameManager.getTableName(BASE_TABLE_NAMES.TRACKING),\n    USER_ADDRESS: TableNameManager.getTableName(BASE_TABLE_NAMES.USER_ADDRESS),\n    USER_SPECIFICS: TableNameManager.getTableName(BASE_TABLE_NAMES.USER_SPECIFICS),\n    BBQ_SKEWERS: TableNameManager.getTableName(BASE_TABLE_NAMES.BBQ_SKEWERS),\n\n    // Other Customer Tables\n    ADD_ONS: TableNameManager.getTableName(BASE_TABLE_NAMES.ADD_ONS),\n    BANK_DETAILS: TableNameManager.getTableName(BASE_TABLE_NAMES.BANK_DETAILS),\n    CART: TableNameManager.getTableName(BASE_TABLE_NAMES.CART),\n    CART_CATEGORIES: TableNameManager.getTableName(BASE_TABLE_NAMES.CART_CATEGORIES),\n    CATEGORY: TableNameManager.getTableName(BASE_TABLE_NAMES.CATEGORY),\n    CATERING: TableNameManager.getTableName(BASE_TABLE_NAMES.CATERING),\n    CONTENT: TableNameManager.getTableName(BASE_TABLE_NAMES.CONTENT),\n    COUPONS: TableNameManager.getTableName(BASE_TABLE_NAMES.COUPONS),\n    DEFAULT_PLATTER: TableNameManager.getTableName(BASE_TABLE_NAMES.DEFAULT_PLATTER),\n    DEFAULT_PLATTER_CATEGORIES: TableNameManager.getTableName(BASE_TABLE_NAMES.DEFAULT_PLATTER_CATEGORIES),\n    DEFAULT_PLATTER_ITEMS: TableNameManager.getTableName(BASE_TABLE_NAMES.DEFAULT_PLATTER_ITEMS),\n    EVENT_EXECUTIVES: TableNameManager.getTableName(BASE_TABLE_NAMES.EVENT_EXECUTIVES),\n    ITEMS: TableNameManager.getTableName(BASE_TABLE_NAMES.ITEMS),\n    LEAD: TableNameManager.getTableName(BASE_TABLE_NAMES.LEAD),\n    OCCASION: TableNameManager.getTableName(BASE_TABLE_NAMES.OCCASION),\n    REFERRAL_CONTENT: TableNameManager.getTableName(BASE_TABLE_NAMES.REFERRAL_CONTENT),\n    USER: TableNameManager.getTableName(BASE_TABLE_NAMES.USER),\n    WALLET: TableNameManager.getTableName(BASE_TABLE_NAMES.WALLET),\n    WALLET_TRANSACTION: TableNameManager.getTableName(BASE_TABLE_NAMES.WALLET_TRANSACTION),\n    WITHDRAWN: TableNameManager.getTableName(BASE_TABLE_NAMES.WITHDRAWN),\n\n    // Internal User Tables\n    INTERNAL_USER: TableNameManager.getTableName(BASE_TABLE_NAMES.INTERNAL_USER),\n    ACTIVITY_LOGS: TableNameManager.getTableName(BASE_TABLE_NAMES.ACTIVITY_LOGS),\n    QUOTATIONS: TableNameManager.getTableName(BASE_TABLE_NAMES.QUOTATIONS),\n} as const;\n"]}

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 {};

package/dist/patner-third-party/third-party-api-key/third-party-api-key-dao.js

@@ -0,0 +1,225 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.thirdPartyApiKeyDao = exports.DuplicateApiKeyHashError = void 0;
+const dynamoose_1 = __importDefault(require("dynamoose"));
+const base_dynamoose_dao_1 = require("../../base-dynamoose-dao");
+const third_party_api_key_model_1 = require("./third-party-api-key-model");
+/**
+ * Thrown when the same `apiKeyHash` already exists in the table.
+ * Use this to return a clean duplicate-key error from admin/create-key APIs.
+ */
+class DuplicateApiKeyHashError extends Error {
+    constructor(apiKeyHash) {
+        super(`apiKeyHash already exists: ${apiKeyHash}`);
+        this.name = "DuplicateApiKeyHashError";
+    }
+}
+exports.DuplicateApiKeyHashError = DuplicateApiKeyHashError;
+/**
+ * DAO for permanent third-party API keys (Method 2).
+ *
+ * Table keys: `partnerId` (PK) + `apiKeyId` (SK).
+ * Auth lookup: hash incoming key, then use `getActiveByApiKeyHash`.
+ */
+class ThirdPartyApiKeyDao extends base_dynamoose_dao_1.GenericDynamooseDAO {
+    constructor() {
+        super(third_party_api_key_model_1.ThirdPartyApiKeyModel, "partnerId", "apiKeyId");
+        /**
+         * 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.
+         */
+        this.save = async (item, authContext) => {
+            const existing = await this.getByApiKeyHash(item.apiKeyHash);
+            if (existing) {
+                throw new DuplicateApiKeyHashError(item.apiKeyHash);
+            }
+            return super.save({
+                ...item,
+                status: item.status ?? third_party_api_key_model_1.THIRD_PARTY_API_KEY_STATUS.ACTIVE
+            }, authContext);
+        };
+        /**
+         * 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.
+         */
+        this.updateApiKey = async (partnerId, apiKeyId, updates, authContext) => {
+            if (updates.apiKeyHash) {
+                const duplicate = await this.getByApiKeyHash(updates.apiKeyHash);
+                if (duplicate && (duplicate.partnerId !== partnerId || duplicate.apiKeyId !== apiKeyId)) {
+                    throw new DuplicateApiKeyHashError(updates.apiKeyHash);
+                }
+            }
+            const updated = await third_party_api_key_model_1.ThirdPartyApiKeyModel.update({ partnerId, apiKeyId }, {
+                ...updates,
+                updated_time: new Date(),
+                updated_user: authContext?.userSub
+            }, {
+                condition: new dynamoose_1.default.Condition().attribute("apiKeyId").exists()
+            });
+            return updated;
+        };
+        /**
+         * 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.
+         */
+        this.getByPartnerAndApiKeyId = async (partnerId, apiKeyId) => this.get(partnerId, apiKeyId);
+        /**
+         * 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`.
+         */
+        this.listByPartnerId = async (partnerId, limit, token) => {
+            const decodedToken = this.decode(token);
+            let queryBuilder = third_party_api_key_model_1.ThirdPartyApiKeyModel.query("partnerId").eq(partnerId);
+            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 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.
+         */
+        this.listByPartnerIdAndStatus = async (partnerId, status, limit, token) => {
+            const decodedToken = this.decode(token);
+            let queryBuilder = third_party_api_key_model_1.ThirdPartyApiKeyModel.query("partnerId")
+                .eq(partnerId)
+                .where("status")
+                .eq(status);
+            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)
+            };
+        };
+        /**
+         * 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.
+         */
+        this.getByApiKeyHash = async (apiKeyHash) => {
+            const result = await this.listByApiKeyHash(apiKeyHash, 1);
+            return result.items[0] ?? 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.
+         */
+        this.getActiveByApiKeyHash = async (apiKeyHash) => {
+            const item = await this.getByApiKeyHash(apiKeyHash);
+            if (!item || item.status !== third_party_api_key_model_1.THIRD_PARTY_API_KEY_STATUS.ACTIVE) {
+                return null;
+            }
+            if (item.expiresAt != null && item.expiresAt <= Date.now()) {
+                return null;
+            }
+            return item;
+        };
+        /**
+         * Records when an API key was last used (audit / monitoring).
+         *
+         * Use when: auth middleware successfully validates a key and you want usage telemetry.
+         */
+        this.touchLastUsedAt = async (partnerId, apiKeyId) => {
+            await third_party_api_key_model_1.ThirdPartyApiKeyModel.update({ partnerId, apiKeyId }, { lastUsedAt: Date.now() });
+        };
+        /**
+         * Paginated query on GSI `apiKeyHashIndex`.
+         *
+         * Use when: low-level lookup by hash with pagination.
+         * Normally prefer `getByApiKeyHash` for single-record auth/admin flows.
+         */
+        this.listByApiKeyHash = async (apiKeyHash, limit, token) => {
+            const decodedToken = this.decode(token);
+            let queryBuilder = third_party_api_key_model_1.ThirdPartyApiKeyModel.query("apiKeyHash")
+                .eq(apiKeyHash)
+                .using("apiKeyHashIndex");
+            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 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.
+         */
+        this.listByStatus = async (status, limit, token) => {
+            const decodedToken = this.decode(token);
+            let queryBuilder = third_party_api_key_model_1.ThirdPartyApiKeyModel.query("status").eq(status).using("statusIndex");
+            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)
+            };
+        };
+        /**
+         * Disables an API key without deleting it (`status` → `INACTIVE`).
+         *
+         * Use when: partner offboarding, key compromise, or temporary suspension.
+         * Disabled keys fail `getActiveByApiKeyHash` immediately.
+         */
+        this.deactivate = async (partnerId, apiKeyId, authContext) => {
+            return this.updateApiKey(partnerId, apiKeyId, { status: third_party_api_key_model_1.THIRD_PARTY_API_KEY_STATUS.INACTIVE }, authContext);
+        };
+        /**
+         * Re-enables a previously disabled key (`status` → `ACTIVE`).
+         *
+         * Use when: restoring partner access after suspension without issuing a new key.
+         */
+        this.activate = async (partnerId, apiKeyId, authContext) => {
+            return this.updateApiKey(partnerId, apiKeyId, { status: third_party_api_key_model_1.THIRD_PARTY_API_KEY_STATUS.ACTIVE }, authContext);
+        };
+    }
+}
+exports.thirdPartyApiKeyDao = new ThirdPartyApiKeyDao();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"third-party-api-key-dao.js","sourceRoot":"","sources":["../../../src/patner-third-party/third-party-api-key/third-party-api-key-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    CreateThirdPartyApiKeyInput,\n    THIRD_PARTY_API_KEY_STATUS,\n    ThirdPartyApiKey,\n    ThirdPartyApiKeyModel,\n    ThirdPartyApiKeyStatus\n} from \"./third-party-api-key-model\";\n\ntype ListResult = {\n    items: ThirdPartyApiKey[];\n    nextToken?: string;\n};\n\n/**\n * Thrown when the same `apiKeyHash` already exists in the table.\n * Use this to return a clean duplicate-key error from admin/create-key APIs.\n */\nexport class DuplicateApiKeyHashError extends Error {\n    constructor(apiKeyHash: string) {\n        super(`apiKeyHash already exists: ${apiKeyHash}`);\n        this.name = \"DuplicateApiKeyHashError\";\n    }\n}\n\n/**\n * DAO for permanent third-party API keys (Method 2).\n *\n * Table keys: `partnerId` (PK) + `apiKeyId` (SK).\n * Auth lookup: hash incoming key, then use `getActiveByApiKeyHash`.\n */\nclass ThirdPartyApiKeyDao extends GenericDynamooseDAO<ThirdPartyApiKey> {\n    constructor() {\n        super(ThirdPartyApiKeyModel, \"partnerId\", \"apiKeyId\");\n    }\n\n    /**\n     * Creates a new permanent API key record for a partner.\n     *\n     * Use when: admin/onboarding flow issues a new API key to a third-party partner.\n     * - `apiKeyId` auto-generates if omitted.\n     * - Pass only `apiKeyHash` (SHA-256 etc.), never the raw key.\n     * - Default status is `ACTIVE`.\n     * - Throws `DuplicateApiKeyHashError` if hash already exists.\n     */\n    save = async (item: CreateThirdPartyApiKeyInput, authContext?: AuthContext): Promise<ThirdPartyApiKey> => {\n        const existing = await this.getByApiKeyHash(item.apiKeyHash);\n        if (existing) {\n            throw new DuplicateApiKeyHashError(item.apiKeyHash);\n        }\n\n        return super.save(\n            {\n                ...item,\n                status: item.status ?? THIRD_PARTY_API_KEY_STATUS.ACTIVE\n            } as ThirdPartyApiKey,\n            authContext\n        );\n    };\n\n    /**\n     * Updates an existing API key by `partnerId` + `apiKeyId`.\n     *\n     * Use when: changing key metadata or rotating hash/status from admin tools.\n     * - Fails if the record does not exist.\n     * - Rejects duplicate `apiKeyHash` belonging to another key.\n     * - Stamps `updated_time` / `updated_user` automatically.\n     */\n    updateApiKey = async (\n        partnerId: string,\n        apiKeyId: string,\n        updates: Partial<ThirdPartyApiKey>,\n        authContext?: AuthContext\n    ): Promise<ThirdPartyApiKey> => {\n        if (updates.apiKeyHash) {\n            const duplicate = await this.getByApiKeyHash(updates.apiKeyHash);\n            if (duplicate && (duplicate.partnerId !== partnerId || duplicate.apiKeyId !== apiKeyId)) {\n                throw new DuplicateApiKeyHashError(updates.apiKeyHash);\n            }\n        }\n\n        const updated = await ThirdPartyApiKeyModel.update(\n            { partnerId, apiKeyId },\n            {\n                ...updates,\n                updated_time: new Date(),\n                updated_user: authContext?.userSub\n            },\n            {\n                condition: new dynamoose.Condition().attribute(\"apiKeyId\").exists()\n            }\n        );\n        return updated as unknown as ThirdPartyApiKey;\n    };\n\n    /**\n     * Fetches one API key by table primary key (`partnerId` + `apiKeyId`).\n     *\n     * Use when: admin detail page, key management screen, or internal ops lookup\n     * when both partner id and key id are already known.\n     */\n    getByPartnerAndApiKeyId = async (\n        partnerId: string,\n        apiKeyId: string\n    ): Promise<ThirdPartyApiKey | null> => this.get(partnerId, apiKeyId);\n\n    /**\n     * Lists all API keys for a partner (query on PK `partnerId`).\n     *\n     * Use when: partner dashboard showing every issued key (active + inactive).\n     * Supports pagination via `limit` and `token`.\n     */\n    listByPartnerId = async (partnerId: string, limit?: number, token?: string): Promise<ListResult> => {\n        const decodedToken = this.decode(token);\n        let queryBuilder = ThirdPartyApiKeyModel.query(\"partnerId\").eq(partnerId);\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 ThirdPartyApiKey[],\n            nextToken: await this.encode(queryResult.lastKey as DynamoKey | undefined)\n        };\n    };\n\n    /**\n     * Lists partner keys filtered by `status` (`ACTIVE` or `INACTIVE`).\n     *\n     * Use when: showing only active keys in UI, or auditing disabled/revoked keys\n     * for one partner without scanning the whole table.\n     */\n    listByPartnerIdAndStatus = async (\n        partnerId: string,\n        status: ThirdPartyApiKeyStatus,\n        limit?: number,\n        token?: string\n    ): Promise<ListResult> => {\n        const decodedToken = this.decode(token);\n        let queryBuilder = ThirdPartyApiKeyModel.query(\"partnerId\")\n            .eq(partnerId)\n            .where(\"status\")\n            .eq(status);\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 ThirdPartyApiKey[],\n            nextToken: await this.encode(queryResult.lastKey as DynamoKey | undefined)\n        };\n    };\n\n    /**\n     * Finds a key by `apiKeyHash` using GSI `apiKeyHashIndex`.\n     *\n     * Use when: you need the record regardless of status (admin/debug),\n     * or before deciding whether to allow auth.\n     * Returns `null` if no key matches the hash.\n     */\n    getByApiKeyHash = async (apiKeyHash: string): Promise<ThirdPartyApiKey | null> => {\n        const result = await this.listByApiKeyHash(apiKeyHash, 1);\n        return result.items[0] ?? null;\n    };\n\n    /**\n     * Validates an incoming API request key (auth middleware use-case).\n     *\n     * Use when: request header/bearer token is hashed and you must allow access\n     * only if the key exists AND `status === ACTIVE` AND not past `expiresAt`.\n     * Returns `null` for missing, inactive, revoked, or expired keys.\n     */\n    getActiveByApiKeyHash = async (apiKeyHash: string): Promise<ThirdPartyApiKey | null> => {\n        const item = await this.getByApiKeyHash(apiKeyHash);\n        if (!item || item.status !== THIRD_PARTY_API_KEY_STATUS.ACTIVE) {\n            return null;\n        }\n        if (item.expiresAt != null && item.expiresAt <= Date.now()) {\n            return null;\n        }\n        return item;\n    };\n\n    /**\n     * Records when an API key was last used (audit / monitoring).\n     *\n     * Use when: auth middleware successfully validates a key and you want usage telemetry.\n     */\n    touchLastUsedAt = async (partnerId: string, apiKeyId: string): Promise<void> => {\n        await ThirdPartyApiKeyModel.update({ partnerId, apiKeyId }, { lastUsedAt: Date.now() });\n    };\n\n    /**\n     * Paginated query on GSI `apiKeyHashIndex`.\n     *\n     * Use when: low-level lookup by hash with pagination.\n     * Normally prefer `getByApiKeyHash` for single-record auth/admin flows.\n     */\n    listByApiKeyHash = async (apiKeyHash: string, limit?: number, token?: string): Promise<ListResult> => {\n        const decodedToken = this.decode(token);\n        let queryBuilder = ThirdPartyApiKeyModel.query(\"apiKeyHash\")\n            .eq(apiKeyHash)\n            .using(\"apiKeyHashIndex\");\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 ThirdPartyApiKey[],\n            nextToken: await this.encode(queryResult.lastKey as DynamoKey | undefined)\n        };\n    };\n\n    /**\n     * Lists keys across all partners by `status` (GSI `statusIndex`).\n     *\n     * Use when: global admin reports — e.g. all active keys, or cleanup job\n     * for all inactive/revoked keys.\n     */\n    listByStatus = async (status: ThirdPartyApiKeyStatus, limit?: number, token?: string): Promise<ListResult> => {\n        const decodedToken = this.decode(token);\n        let queryBuilder = ThirdPartyApiKeyModel.query(\"status\").eq(status).using(\"statusIndex\");\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 ThirdPartyApiKey[],\n            nextToken: await this.encode(queryResult.lastKey as DynamoKey | undefined)\n        };\n    };\n\n    /**\n     * Disables an API key without deleting it (`status` → `INACTIVE`).\n     *\n     * Use when: partner offboarding, key compromise, or temporary suspension.\n     * Disabled keys fail `getActiveByApiKeyHash` immediately.\n     */\n    deactivate = async (\n        partnerId: string,\n        apiKeyId: string,\n        authContext?: AuthContext\n    ): Promise<ThirdPartyApiKey> => {\n        return this.updateApiKey(\n            partnerId,\n            apiKeyId,\n            { status: THIRD_PARTY_API_KEY_STATUS.INACTIVE },\n            authContext\n        );\n    };\n\n    /**\n     * Re-enables a previously disabled key (`status` → `ACTIVE`).\n     *\n     * Use when: restoring partner access after suspension without issuing a new key.\n     */\n    activate = async (\n        partnerId: string,\n        apiKeyId: string,\n        authContext?: AuthContext\n    ): Promise<ThirdPartyApiKey> => {\n        return this.updateApiKey(\n            partnerId,\n            apiKeyId,\n            { status: THIRD_PARTY_API_KEY_STATUS.ACTIVE },\n            authContext\n        );\n    };\n}\n\nexport const thirdPartyApiKeyDao = new ThirdPartyApiKeyDao();\n"]}

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

@@ -0,0 +1,21 @@
+import { BaseDynamooseModel } from "../../base-dynamoose-model";
+export declare const THIRD_PARTY_API_KEY_STATUS: {
+    readonly ACTIVE: "ACTIVE";
+    readonly INACTIVE: "INACTIVE";
+};
+export type ThirdPartyApiKeyStatus = (typeof THIRD_PARTY_API_KEY_STATUS)[keyof typeof THIRD_PARTY_API_KEY_STATUS];
+export interface ThirdPartyApiKey extends BaseDynamooseModel {
+    partnerId: string;
+    partnerName: string;
+    apiKeyId: string;
+    apiKeyHash: string;
+    status: ThirdPartyApiKeyStatus;
+    scopes: string[];
+    expiresAt?: number;
+    lastUsedAt?: number;
+}
+export type CreateThirdPartyApiKeyInput = Omit<ThirdPartyApiKey, "apiKeyId"> & {
+    apiKeyId?: string;
+};
+export declare const ThirdPartyApiKeyModel: import("dynamoose/dist/General").ModelType<ThirdPartyApiKey>;
+export declare const convertToThirdPartyApiKeyModel: (input: CreateThirdPartyApiKeyInput | ThirdPartyApiKey) => ThirdPartyApiKey;

package/dist/patner-third-party/third-party-api-key/third-party-api-key-model.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToThirdPartyApiKeyModel = exports.ThirdPartyApiKeyModel = exports.THIRD_PARTY_API_KEY_STATUS = 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.THIRD_PARTY_API_KEY_STATUS = {
+    ACTIVE: "ACTIVE",
+    INACTIVE: "INACTIVE"
+};
+const thirdPartyApiKeySchema = new dynamoose_1.default.Schema({
+    partnerId: {
+        type: String,
+        hashKey: true,
+        required: true
+    },
+    partnerName: {
+        type: String,
+        required: true
+    },
+    apiKeyId: {
+        type: String,
+        rangeKey: true,
+        required: true,
+        default: () => (0, crypto_1.randomUUID)()
+    },
+    apiKeyHash: {
+        type: String,
+        required: true,
+        index: {
+            name: "apiKeyHashIndex",
+            type: "global"
+        }
+    },
+    status: {
+        type: String,
+        required: true,
+        enum: [exports.THIRD_PARTY_API_KEY_STATUS.ACTIVE, exports.THIRD_PARTY_API_KEY_STATUS.INACTIVE],
+        default: exports.THIRD_PARTY_API_KEY_STATUS.ACTIVE,
+        index: {
+            name: "statusIndex",
+            type: "global"
+        }
+    },
+    scopes: {
+        type: Array,
+        schema: [String],
+        required: true
+    },
+    expiresAt: {
+        type: Number
+    },
+    lastUsedAt: {
+        type: Number
+    },
+    ...base_dynamoose_model_1.BASE_DYNAMOOSE_AUDIT_SCHEMA
+}, {
+    saveUnknown: false,
+    timestamps: true
+});
+exports.ThirdPartyApiKeyModel = dynamoose_1.default.model(table_names_1.TABLE_NAMES.THIRD_PARTY_API_KEY, thirdPartyApiKeySchema, { create: false, waitForActive: false });
+const convertToThirdPartyApiKeyModel = (input) => {
+    return new exports.ThirdPartyApiKeyModel(input);
+};
+exports.convertToThirdPartyApiKeyModel = convertToThirdPartyApiKeyModel;
+//# sourceMappingURL=data:application/json;base64,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

package/index.js

@@ -59,4 +59,6 @@ export { walletDao } from './dist/customer-user/wallet/wallet-dao';
 export { WalletTransactionModel } from './dist/customer-user/wallet-transaction/wallet-transaction-model';
 export { walletTransactionDao } from './dist/customer-user/wallet-transaction/wallet-transaction-dao';
 export { WithdrawnModel } from './dist/customer-user/withdrawn/withdrawn-model';
-export { withdrawnDao } from './dist/customer-user/withdrawn/withdrawn-dao';
+export { withdrawnDao } from './dist/customer-user/withdrawn/withdrawn-dao';
+export { ThirdPartyApiKeyModel } from './dist/patner-third-party/third-party-api-key/third-party-api-key-model';
+export { thirdPartyApiKeyDao } from './dist/patner-third-party/third-party-api-key/third-party-api-key-dao';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cmp-aws-database",
-  "version": "2.1.2-dev.10",
+  "version": "2.1.2-dev.11",
   "bin": {
     "craft-my-plate-database": "bin/craft-my-plate-database.js"
   },