cmp-aws-database 2.1.2-dev.7 → 2.1.2-dev.70

package/dist/customer-user/default-platter/default_platters_items.js

@@ -46,6 +46,10 @@ __decorate([
     (0, annotations_1.attribute)(),
     __metadata("design:type", Number)
 ], DefaultPlattersItems.prototype, "itemQuantity", void 0);
+__decorate([
+    (0, annotations_1.attribute)(),
+    __metadata("design:type", Number)
+], DefaultPlattersItems.prototype, "itemMaxQuantity", void 0);
 __decorate([
     (0, annotations_1.attribute)(),
     __metadata("design:type", String)
@@ -85,4 +89,4 @@ __decorate([
 exports.DefaultPlattersItems = DefaultPlattersItems = __decorate([
     (0, annotations_1.table)("DefaultPlatterItemsTable")
 ], DefaultPlattersItems);
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/customer-user/elphie/elphie-errors.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Typed errors for Elphie DynamoDB access — callers should not see raw Dynamoose/AWS errors.
+ */
+export declare class SessionNotFoundError extends Error {
+    readonly statusCode = 404;
+    constructor(elphieSessionId: string);
+}
+export declare class ConversationNotFoundError extends Error {
+    readonly statusCode = 404;
+    constructor(conversationId: string);
+}
+export declare class ElphieValidationError extends Error {
+    readonly statusCode = 400;
+    constructor(message: string);
+}

package/dist/customer-user/elphie/elphie-errors.js

@@ -0,0 +1,31 @@
+"use strict";
+/**
+ * Typed errors for Elphie DynamoDB access — callers should not see raw Dynamoose/AWS errors.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ElphieValidationError = exports.ConversationNotFoundError = exports.SessionNotFoundError = void 0;
+class SessionNotFoundError extends Error {
+    constructor(elphieSessionId) {
+        super(`Elphie session not found: ${elphieSessionId}`);
+        this.statusCode = 404;
+        this.name = "SessionNotFoundError";
+    }
+}
+exports.SessionNotFoundError = SessionNotFoundError;
+class ConversationNotFoundError extends Error {
+    constructor(conversationId) {
+        super(`Elphie conversation not found: ${conversationId}`);
+        this.statusCode = 404;
+        this.name = "ConversationNotFoundError";
+    }
+}
+exports.ConversationNotFoundError = ConversationNotFoundError;
+class ElphieValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.statusCode = 400;
+        this.name = "ElphieValidationError";
+    }
+}
+exports.ElphieValidationError = ElphieValidationError;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/customer-user/elphie/elphie-message-dao.d.ts

@@ -0,0 +1,51 @@
+import { DynamoKey } from "../../base-dynamoose-dao";
+import { CreateElphieConversationInput, ElphieMessage, ElphieMessageTurn } from "./elphie-message-model";
+type ListResult = {
+    items: ElphieMessage[];
+    lastKey?: DynamoKey;
+};
+/**
+ * Service/DAO for `elphie_messages`.
+ *
+ * HASH: `conversation_id`.
+ * Turn append uses Dynamoose `$APPEND` (atomic) — never full-item read-modify-write.
+ */
+declare class ElphieMessageService {
+    /**
+     * Creates a conversation with the first turn already in `content`.
+     *
+     * @example
+     * await elphieMessageService.createConversation({
+     *     conversation_id: "conv-1",
+     *     user_id: "user-1",
+     *     elphieSessionId: "session-uuid",
+     *     firstTurn: { role: "user", text: "Hi", timestamp: new Date().toISOString() }
+     * });
+     */
+    createConversation: (input: CreateElphieConversationInput) => Promise<ElphieMessage>;
+    /**
+     * Atomically appends one turn to `content` and refreshes `updated_at`.
+     * Uses `$APPEND` so concurrent turns cannot lose updates.
+     */
+    appendTurn: (conversation_id: string, turn: ElphieMessageTurn) => Promise<ElphieMessage>;
+    /**
+     * Fetches one conversation by `conversation_id`.
+     * Throws `ConversationNotFoundError` when missing.
+     */
+    getConversation: (conversation_id: string) => Promise<ElphieMessage>;
+    /**
+     * Lists conversations for a user via GSI `user_id-index`.
+     * Newest-first order is applied in memory on `updated_at` (not a GSI range key).
+     */
+    listConversationsForUser: (user_id: string, { limit, lastKey }?: {
+        limit?: number;
+        lastKey?: DynamoKey;
+    }) => Promise<ListResult>;
+    /**
+     * Lists conversations linked to a session via GSI `elphieSessionId-index`.
+     */
+    listConversationsForSession: (elphieSessionId: string) => Promise<ElphieMessage[]>;
+    private assertValidTurn;
+}
+export declare const elphieMessageService: ElphieMessageService;
+export {};

package/dist/customer-user/elphie/elphie-message-dao.js

@@ -0,0 +1,160 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.elphieMessageService = void 0;
+const dynamoose_1 = __importDefault(require("dynamoose"));
+const elphie_errors_1 = require("./elphie-errors");
+const elphie_message_model_1 = require("./elphie-message-model");
+const nowIso = () => new Date().toISOString();
+const isValidRole = (role) => role === elphie_message_model_1.ELPHIE_MESSAGE_ROLE.USER || role === elphie_message_model_1.ELPHIE_MESSAGE_ROLE.ELPHIE;
+/**
+ * Service/DAO for `elphie_messages`.
+ *
+ * HASH: `conversation_id`.
+ * Turn append uses Dynamoose `$APPEND` (atomic) — never full-item read-modify-write.
+ */
+class ElphieMessageService {
+    constructor() {
+        /**
+         * Creates a conversation with the first turn already in `content`.
+         *
+         * @example
+         * await elphieMessageService.createConversation({
+         *     conversation_id: "conv-1",
+         *     user_id: "user-1",
+         *     elphieSessionId: "session-uuid",
+         *     firstTurn: { role: "user", text: "Hi", timestamp: new Date().toISOString() }
+         * });
+         */
+        this.createConversation = async (input) => {
+            this.assertValidTurn(input.firstTurn);
+            try {
+                const created = await elphie_message_model_1.ElphieMessageModel.create({
+                    conversation_id: input.conversation_id,
+                    user_id: input.user_id,
+                    elphieSessionId: input.elphieSessionId,
+                    content: [input.firstTurn],
+                    updated_at: nowIso()
+                });
+                return created;
+            }
+            catch (error) {
+                throw wrapUnexpected("createConversation", error);
+            }
+        };
+        /**
+         * Atomically appends one turn to `content` and refreshes `updated_at`.
+         * Uses `$APPEND` so concurrent turns cannot lose updates.
+         */
+        this.appendTurn = async (conversation_id, turn) => {
+            this.assertValidTurn(turn);
+            try {
+                // Dynamoose list append operator — not expressible as Partial<ElphieMessage>.
+                const updateObj = {
+                    content: { $APPEND: [turn] },
+                    updated_at: nowIso()
+                };
+                const updated = await elphie_message_model_1.ElphieMessageModel.update({ conversation_id }, updateObj, {
+                    condition: new dynamoose_1.default.Condition().attribute("conversation_id").exists()
+                });
+                return updated;
+            }
+            catch (error) {
+                if (isNotFoundError(error) || isConditionalCheckFailed(error)) {
+                    throw new elphie_errors_1.ConversationNotFoundError(conversation_id);
+                }
+                throw wrapUnexpected("appendTurn", error);
+            }
+        };
+        /**
+         * Fetches one conversation by `conversation_id`.
+         * Throws `ConversationNotFoundError` when missing.
+         */
+        this.getConversation = async (conversation_id) => {
+            try {
+                const conversation = await elphie_message_model_1.ElphieMessageModel.get(conversation_id);
+                if (!conversation) {
+                    throw new elphie_errors_1.ConversationNotFoundError(conversation_id);
+                }
+                return conversation;
+            }
+            catch (error) {
+                if (error instanceof elphie_errors_1.ConversationNotFoundError) {
+                    throw error;
+                }
+                if (isNotFoundError(error)) {
+                    throw new elphie_errors_1.ConversationNotFoundError(conversation_id);
+                }
+                throw wrapUnexpected("getConversation", error);
+            }
+        };
+        /**
+         * Lists conversations for a user via GSI `user_id-index`.
+         * Newest-first order is applied in memory on `updated_at` (not a GSI range key).
+         */
+        this.listConversationsForUser = async (user_id, { limit, lastKey } = {}) => {
+            try {
+                let queryBuilder = elphie_message_model_1.ElphieMessageModel.query("user_id")
+                    .eq(user_id)
+                    .using("user_id-index");
+                if (lastKey) {
+                    queryBuilder = queryBuilder.startAt(lastKey);
+                }
+                if (typeof limit === "number") {
+                    queryBuilder = queryBuilder.limit(limit);
+                }
+                const queryResult = await queryBuilder.exec();
+                const items = [...queryResult].sort((a, b) => (b.updated_at ?? "").localeCompare(a.updated_at ?? ""));
+                return {
+                    items,
+                    lastKey: queryResult.lastKey
+                };
+            }
+            catch (error) {
+                throw wrapUnexpected("listConversationsForUser", error);
+            }
+        };
+        /**
+         * Lists conversations linked to a session via GSI `elphieSessionId-index`.
+         */
+        this.listConversationsForSession = async (elphieSessionId) => {
+            try {
+                const queryResult = await elphie_message_model_1.ElphieMessageModel.query("elphieSessionId")
+                    .eq(elphieSessionId)
+                    .using("elphieSessionId-index")
+                    .exec();
+                return queryResult;
+            }
+            catch (error) {
+                throw wrapUnexpected("listConversationsForSession", error);
+            }
+        };
+        this.assertValidTurn = (turn) => {
+            if (!turn || typeof turn.text !== "string" || turn.text.length === 0) {
+                throw new elphie_errors_1.ElphieValidationError("turn.text is required");
+            }
+            if (!isValidRole(turn.role)) {
+                throw new elphie_errors_1.ElphieValidationError(`Invalid turn.role "${turn.role}". Expected "user" | "elphie".`);
+            }
+            if (!turn.timestamp) {
+                throw new elphie_errors_1.ElphieValidationError("turn.timestamp is required");
+            }
+        };
+    }
+}
+const isNotFoundError = (error) => {
+    const name = error?.name;
+    return name === "ItemNotFoundException" || name === "ItemNotFoundError";
+};
+const isConditionalCheckFailed = (error) => {
+    const name = error?.name;
+    return name === "ConditionalCheckFailedException";
+};
+const wrapUnexpected = (operation, error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    return new Error(`ElphieMessageService.${operation} failed: ${message}`);
+};
+exports.elphieMessageService = new ElphieMessageService();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"elphie-message-dao.js","sourceRoot":"","sources":["../../../src/customer-user/elphie/elphie-message-dao.ts"],"names":[],"mappings":"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","sourcesContent":["import dynamoose from \"dynamoose\";\nimport { DynamoKey } from \"../../base-dynamoose-dao\";\nimport { ConversationNotFoundError, ElphieValidationError } from \"./elphie-errors\";\nimport {\n    CreateElphieConversationInput,\n    ELPHIE_MESSAGE_ROLE,\n    ElphieMessage,\n    ElphieMessageModel,\n    ElphieMessageRole,\n    ElphieMessageTurn\n} from \"./elphie-message-model\";\n\ntype ListResult = {\n    items: ElphieMessage[];\n    lastKey?: DynamoKey;\n};\n\nconst nowIso = (): string => new Date().toISOString();\n\nconst isValidRole = (role: string): role is ElphieMessageRole =>\n    role === ELPHIE_MESSAGE_ROLE.USER || role === ELPHIE_MESSAGE_ROLE.ELPHIE;\n\n/**\n * Service/DAO for `elphie_messages`.\n *\n * HASH: `conversation_id`.\n * Turn append uses Dynamoose `$APPEND` (atomic) — never full-item read-modify-write.\n */\nclass ElphieMessageService {\n    /**\n     * Creates a conversation with the first turn already in `content`.\n     *\n     * @example\n     * await elphieMessageService.createConversation({\n     *     conversation_id: \"conv-1\",\n     *     user_id: \"user-1\",\n     *     elphieSessionId: \"session-uuid\",\n     *     firstTurn: { role: \"user\", text: \"Hi\", timestamp: new Date().toISOString() }\n     * });\n     */\n    createConversation = async (input: CreateElphieConversationInput): Promise<ElphieMessage> => {\n        this.assertValidTurn(input.firstTurn);\n\n        try {\n            const created = await ElphieMessageModel.create({\n                conversation_id: input.conversation_id,\n                user_id: input.user_id,\n                elphieSessionId: input.elphieSessionId,\n                content: [input.firstTurn],\n                updated_at: nowIso()\n            });\n            return created as ElphieMessage;\n        } catch (error) {\n            throw wrapUnexpected(\"createConversation\", error);\n        }\n    };\n\n    /**\n     * Atomically appends one turn to `content` and refreshes `updated_at`.\n     * Uses `$APPEND` so concurrent turns cannot lose updates.\n     */\n    appendTurn = async (conversation_id: string, turn: ElphieMessageTurn): Promise<ElphieMessage> => {\n        this.assertValidTurn(turn);\n\n        try {\n            // Dynamoose list append operator — not expressible as Partial<ElphieMessage>.\n            const updateObj = {\n                content: { $APPEND: [turn] },\n                updated_at: nowIso()\n            };\n            const updated = await ElphieMessageModel.update(\n                { conversation_id },\n                updateObj as unknown as Parameters<typeof ElphieMessageModel.update>[1],\n                {\n                    condition: new dynamoose.Condition().attribute(\"conversation_id\").exists()\n                }\n            );\n            return updated as unknown as ElphieMessage;\n        } catch (error) {\n            if (isNotFoundError(error) || isConditionalCheckFailed(error)) {\n                throw new ConversationNotFoundError(conversation_id);\n            }\n            throw wrapUnexpected(\"appendTurn\", error);\n        }\n    };\n\n    /**\n     * Fetches one conversation by `conversation_id`.\n     * Throws `ConversationNotFoundError` when missing.\n     */\n    getConversation = async (conversation_id: string): Promise<ElphieMessage> => {\n        try {\n            const conversation = await ElphieMessageModel.get(conversation_id);\n            if (!conversation) {\n                throw new ConversationNotFoundError(conversation_id);\n            }\n            return conversation as ElphieMessage;\n        } catch (error) {\n            if (error instanceof ConversationNotFoundError) {\n                throw error;\n            }\n            if (isNotFoundError(error)) {\n                throw new ConversationNotFoundError(conversation_id);\n            }\n            throw wrapUnexpected(\"getConversation\", error);\n        }\n    };\n\n    /**\n     * Lists conversations for a user via GSI `user_id-index`.\n     * Newest-first order is applied in memory on `updated_at` (not a GSI range key).\n     */\n    listConversationsForUser = async (\n        user_id: string,\n        { limit, lastKey }: { limit?: number; lastKey?: DynamoKey } = {}\n    ): Promise<ListResult> => {\n        try {\n            let queryBuilder = ElphieMessageModel.query(\"user_id\")\n                .eq(user_id)\n                .using(\"user_id-index\");\n\n            if (lastKey) {\n                queryBuilder = queryBuilder.startAt(lastKey);\n            }\n            if (typeof limit === \"number\") {\n                queryBuilder = queryBuilder.limit(limit);\n            }\n\n            const queryResult = await queryBuilder.exec();\n            const items = [...(queryResult as unknown as ElphieMessage[])].sort((a, b) =>\n                (b.updated_at ?? \"\").localeCompare(a.updated_at ?? \"\")\n            );\n            return {\n                items,\n                lastKey: queryResult.lastKey as DynamoKey | undefined\n            };\n        } catch (error) {\n            throw wrapUnexpected(\"listConversationsForUser\", error);\n        }\n    };\n\n    /**\n     * Lists conversations linked to a session via GSI `elphieSessionId-index`.\n     */\n    listConversationsForSession = async (elphieSessionId: string): Promise<ElphieMessage[]> => {\n        try {\n            const queryResult = await ElphieMessageModel.query(\"elphieSessionId\")\n                .eq(elphieSessionId)\n                .using(\"elphieSessionId-index\")\n                .exec();\n            return queryResult as unknown as ElphieMessage[];\n        } catch (error) {\n            throw wrapUnexpected(\"listConversationsForSession\", error);\n        }\n    };\n\n    private assertValidTurn = (turn: ElphieMessageTurn): void => {\n        if (!turn || typeof turn.text !== \"string\" || turn.text.length === 0) {\n            throw new ElphieValidationError(\"turn.text is required\");\n        }\n        if (!isValidRole(turn.role)) {\n            throw new ElphieValidationError(\n                `Invalid turn.role \"${turn.role}\". Expected \"user\" | \"elphie\".`\n            );\n        }\n        if (!turn.timestamp) {\n            throw new ElphieValidationError(\"turn.timestamp is required\");\n        }\n    };\n}\n\nconst isNotFoundError = (error: unknown): boolean => {\n    const name = (error as { name?: string } | null)?.name;\n    return name === \"ItemNotFoundException\" || name === \"ItemNotFoundError\";\n};\n\nconst isConditionalCheckFailed = (error: unknown): boolean => {\n    const name = (error as { name?: string } | null)?.name;\n    return name === \"ConditionalCheckFailedException\";\n};\n\nconst wrapUnexpected = (operation: string, error: unknown): Error => {\n    const message = error instanceof Error ? error.message : String(error);\n    return new Error(`ElphieMessageService.${operation} failed: ${message}`);\n};\n\nexport const elphieMessageService = new ElphieMessageService();\n"]}

package/dist/customer-user/elphie/elphie-message-model.d.ts

@@ -0,0 +1,25 @@
+import { Item } from "dynamoose/dist/Item";
+export declare const ELPHIE_MESSAGE_ROLE: {
+    readonly USER: "user";
+    readonly ELPHIE: "elphie";
+};
+export type ElphieMessageRole = (typeof ELPHIE_MESSAGE_ROLE)[keyof typeof ELPHIE_MESSAGE_ROLE];
+export interface ElphieMessageTurn {
+    role: ElphieMessageRole;
+    text: string;
+    timestamp: string;
+}
+export interface ElphieMessage extends Item {
+    conversation_id: string;
+    user_id: string;
+    elphieSessionId: string;
+    content: ElphieMessageTurn[];
+    updated_at: string;
+}
+export type CreateElphieConversationInput = {
+    conversation_id: string;
+    user_id: string;
+    elphieSessionId: string;
+    firstTurn: ElphieMessageTurn;
+};
+export declare const ElphieMessageModel: import("dynamoose/dist/General").ModelType<ElphieMessage>;

package/dist/customer-user/elphie/elphie-message-model.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ElphieMessageModel = exports.ELPHIE_MESSAGE_ROLE = void 0;
+const dynamoose_1 = __importDefault(require("dynamoose"));
+const table_names_1 = require("../../config/table-names");
+exports.ELPHIE_MESSAGE_ROLE = {
+    USER: "user",
+    ELPHIE: "elphie"
+};
+/**
+ * Dynamoose schema for `elphie_messages`.
+ *
+ * HASH: `conversation_id`.
+ * GSI `user_id-index`: HASH `user_id` only (`updated_at` is a plain attribute).
+ * GSI `elphieSessionId-index`: HASH `elphieSessionId` (links to `elphie_sessions`).
+ *
+ * `create: false` — tables + GSIs are provisioned via CDK, not auto-created on boot.
+ */
+const elphieMessageSchema = new dynamoose_1.default.Schema({
+    conversation_id: {
+        type: String,
+        hashKey: true,
+        required: true
+    },
+    user_id: {
+        type: String,
+        required: true,
+        index: {
+            name: "user_id-index",
+            type: "global"
+        }
+    },
+    elphieSessionId: {
+        type: String,
+        required: true,
+        index: {
+            name: "elphieSessionId-index",
+            type: "global"
+        }
+    },
+    content: {
+        type: Array,
+        schema: [
+            {
+                type: Object,
+                schema: {
+                    role: {
+                        type: String,
+                        required: true,
+                        enum: [exports.ELPHIE_MESSAGE_ROLE.USER, exports.ELPHIE_MESSAGE_ROLE.ELPHIE]
+                    },
+                    text: {
+                        type: String,
+                        required: true
+                    },
+                    timestamp: {
+                        type: String,
+                        required: true
+                    }
+                }
+            }
+        ],
+        required: true,
+        default: []
+    },
+    updated_at: {
+        type: String,
+        required: true
+    }
+}, {
+    saveUnknown: false,
+    timestamps: true
+});
+exports.ElphieMessageModel = dynamoose_1.default.model(table_names_1.TABLE_NAMES.ELPHIE_MESSAGES, elphieMessageSchema, { create: false, waitForActive: false });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/customer-user/elphie/elphie-session-dao.d.ts

@@ -0,0 +1,46 @@
+import { DynamoKey } from "../../base-dynamoose-dao";
+import { CreateElphieSessionInput, ElphieSession } from "./elphie-session-model";
+type ListResult = {
+    items: ElphieSession[];
+    lastKey?: DynamoKey;
+};
+/**
+ * Service/DAO for `elphie_sessions`.
+ *
+ * HASH: `elphieSessionId` (UUID set here — never schema-defaulted).
+ * List-by-user: GSI `user_id-index`.
+ */
+declare class ElphieSessionService {
+    /**
+     * Creates a session. Generates `elphieSessionId` via `randomUUID()` and stamps ISO UTC times.
+     *
+     * @example
+     * const session = await elphieSessionService.createSession({
+     *     user_id: "user-1",
+     *     conversation_id: "conv-1",
+     *     title: "Birthday planning",
+     *     fmp_context: { occasion: "birthday" }
+     * });
+     */
+    createSession: (input: CreateElphieSessionInput) => Promise<ElphieSession>;
+    /**
+     * Fetches one session by `elphieSessionId`.
+     * Throws `SessionNotFoundError` when missing.
+     */
+    getSessionById: (elphieSessionId: string) => Promise<ElphieSession>;
+    /**
+     * Lists sessions for a user via GSI `user_id-index`.
+     * Newest-first order is applied in memory on `created_at` (not a GSI range key).
+     * Pass `lastKey` from the previous response for pagination.
+     */
+    listSessionsForUser: (user_id: string, { limit, lastKey }?: {
+        limit?: number;
+        lastKey?: DynamoKey;
+    }) => Promise<ListResult>;
+    /**
+     * Atomically updates session `title` + `updated_at`.
+     */
+    updateSessionTitle: (elphieSessionId: string, title: string) => Promise<ElphieSession>;
+}
+export declare const elphieSessionService: ElphieSessionService;
+export {};

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

@@ -0,0 +1,134 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.elphieSessionService = void 0;
+const crypto_1 = require("crypto");
+const dynamoose_1 = __importDefault(require("dynamoose"));
+const elphie_errors_1 = require("./elphie-errors");
+const elphie_session_model_1 = require("./elphie-session-model");
+const nowIso = () => new Date().toISOString();
+/**
+ * Service/DAO for `elphie_sessions`.
+ *
+ * HASH: `elphieSessionId` (UUID set here — never schema-defaulted).
+ * List-by-user: GSI `user_id-index`.
+ */
+class ElphieSessionService {
+    constructor() {
+        /**
+         * Creates a session. Generates `elphieSessionId` via `randomUUID()` and stamps ISO UTC times.
+         *
+         * @example
+         * const session = await elphieSessionService.createSession({
+         *     user_id: "user-1",
+         *     conversation_id: "conv-1",
+         *     title: "Birthday planning",
+         *     fmp_context: { occasion: "birthday" }
+         * });
+         */
+        this.createSession = async (input) => {
+            try {
+                const now = nowIso();
+                const created = await elphie_session_model_1.ElphieSessionModel.create({
+                    elphieSessionId: (0, crypto_1.randomUUID)(),
+                    user_id: input.user_id,
+                    conversation_id: input.conversation_id,
+                    title: input.title,
+                    fmp_context: input.fmp_context,
+                    created_at: now,
+                    updated_at: now
+                });
+                return created;
+            }
+            catch (error) {
+                throw wrapUnexpected("createSession", error);
+            }
+        };
+        /**
+         * Fetches one session by `elphieSessionId`.
+         * Throws `SessionNotFoundError` when missing.
+         */
+        this.getSessionById = async (elphieSessionId) => {
+            try {
+                const session = await elphie_session_model_1.ElphieSessionModel.get(elphieSessionId);
+                if (!session) {
+                    throw new elphie_errors_1.SessionNotFoundError(elphieSessionId);
+                }
+                return session;
+            }
+            catch (error) {
+                if (error instanceof elphie_errors_1.SessionNotFoundError) {
+                    throw error;
+                }
+                // Dynamoose may throw ItemNotFoundError depending on settings
+                if (isNotFoundError(error)) {
+                    throw new elphie_errors_1.SessionNotFoundError(elphieSessionId);
+                }
+                throw wrapUnexpected("getSessionById", error);
+            }
+        };
+        /**
+         * Lists sessions for a user via GSI `user_id-index`.
+         * Newest-first order is applied in memory on `created_at` (not a GSI range key).
+         * Pass `lastKey` from the previous response for pagination.
+         */
+        this.listSessionsForUser = async (user_id, { limit, lastKey } = {}) => {
+            try {
+                let queryBuilder = elphie_session_model_1.ElphieSessionModel.query("user_id")
+                    .eq(user_id)
+                    .using("user_id-index");
+                if (lastKey) {
+                    queryBuilder = queryBuilder.startAt(lastKey);
+                }
+                if (typeof limit === "number") {
+                    queryBuilder = queryBuilder.limit(limit);
+                }
+                const queryResult = await queryBuilder.exec();
+                const items = [...queryResult].sort((a, b) => (b.created_at ?? "").localeCompare(a.created_at ?? ""));
+                return {
+                    items,
+                    lastKey: queryResult.lastKey
+                };
+            }
+            catch (error) {
+                throw wrapUnexpected("listSessionsForUser", error);
+            }
+        };
+        /**
+         * Atomically updates session `title` + `updated_at`.
+         */
+        this.updateSessionTitle = async (elphieSessionId, title) => {
+            try {
+                const updated = await elphie_session_model_1.ElphieSessionModel.update({ elphieSessionId }, {
+                    title,
+                    updated_at: nowIso()
+                }, {
+                    condition: new dynamoose_1.default.Condition().attribute("elphieSessionId").exists()
+                });
+                return updated;
+            }
+            catch (error) {
+                if (isNotFoundError(error) || isConditionalCheckFailed(error)) {
+                    throw new elphie_errors_1.SessionNotFoundError(elphieSessionId);
+                }
+                throw wrapUnexpected("updateSessionTitle", error);
+            }
+        };
+    }
+}
+const isNotFoundError = (error) => {
+    const name = error?.name;
+    return name === "ItemNotFoundException" || name === "ItemNotFoundError";
+};
+const isConditionalCheckFailed = (error) => {
+    const name = error?.name;
+    return name === "ConditionalCheckFailedException";
+};
+const wrapUnexpected = (operation, error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    return new Error(`ElphieSessionService.${operation} failed: ${message}`);
+};
+exports.elphieSessionService = new ElphieSessionService();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"elphie-session-dao.js","sourceRoot":"","sources":["../../../src/customer-user/elphie/elphie-session-dao.ts"],"names":[],"mappings":"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","sourcesContent":["import { randomUUID } from \"crypto\";\nimport dynamoose from \"dynamoose\";\nimport { DynamoKey } from \"../../base-dynamoose-dao\";\nimport { SessionNotFoundError } from \"./elphie-errors\";\nimport {\n    CreateElphieSessionInput,\n    ElphieSession,\n    ElphieSessionModel\n} from \"./elphie-session-model\";\n\ntype ListResult = {\n    items: ElphieSession[];\n    lastKey?: DynamoKey;\n};\n\nconst nowIso = (): string => new Date().toISOString();\n\n/**\n * Service/DAO for `elphie_sessions`.\n *\n * HASH: `elphieSessionId` (UUID set here — never schema-defaulted).\n * List-by-user: GSI `user_id-index`.\n */\nclass ElphieSessionService {\n    /**\n     * Creates a session. Generates `elphieSessionId` via `randomUUID()` and stamps ISO UTC times.\n     *\n     * @example\n     * const session = await elphieSessionService.createSession({\n     *     user_id: \"user-1\",\n     *     conversation_id: \"conv-1\",\n     *     title: \"Birthday planning\",\n     *     fmp_context: { occasion: \"birthday\" }\n     * });\n     */\n    createSession = async (input: CreateElphieSessionInput): Promise<ElphieSession> => {\n        try {\n            const now = nowIso();\n            const created = await ElphieSessionModel.create({\n                elphieSessionId: randomUUID(),\n                user_id: input.user_id,\n                conversation_id: input.conversation_id,\n                title: input.title,\n                fmp_context: input.fmp_context,\n                created_at: now,\n                updated_at: now\n            });\n            return created as ElphieSession;\n        } catch (error) {\n            throw wrapUnexpected(\"createSession\", error);\n        }\n    };\n\n    /**\n     * Fetches one session by `elphieSessionId`.\n     * Throws `SessionNotFoundError` when missing.\n     */\n    getSessionById = async (elphieSessionId: string): Promise<ElphieSession> => {\n        try {\n            const session = await ElphieSessionModel.get(elphieSessionId);\n            if (!session) {\n                throw new SessionNotFoundError(elphieSessionId);\n            }\n            return session as ElphieSession;\n        } catch (error) {\n            if (error instanceof SessionNotFoundError) {\n                throw error;\n            }\n            // Dynamoose may throw ItemNotFoundError depending on settings\n            if (isNotFoundError(error)) {\n                throw new SessionNotFoundError(elphieSessionId);\n            }\n            throw wrapUnexpected(\"getSessionById\", error);\n        }\n    };\n\n    /**\n     * Lists sessions for a user via GSI `user_id-index`.\n     * Newest-first order is applied in memory on `created_at` (not a GSI range key).\n     * Pass `lastKey` from the previous response for pagination.\n     */\n    listSessionsForUser = async (\n        user_id: string,\n        { limit, lastKey }: { limit?: number; lastKey?: DynamoKey } = {}\n    ): Promise<ListResult> => {\n        try {\n            let queryBuilder = ElphieSessionModel.query(\"user_id\")\n                .eq(user_id)\n                .using(\"user_id-index\");\n\n            if (lastKey) {\n                queryBuilder = queryBuilder.startAt(lastKey);\n            }\n            if (typeof limit === \"number\") {\n                queryBuilder = queryBuilder.limit(limit);\n            }\n\n            const queryResult = await queryBuilder.exec();\n            const items = [...(queryResult as unknown as ElphieSession[])].sort((a, b) =>\n                (b.created_at ?? \"\").localeCompare(a.created_at ?? \"\")\n            );\n            return {\n                items,\n                lastKey: queryResult.lastKey as DynamoKey | undefined\n            };\n        } catch (error) {\n            throw wrapUnexpected(\"listSessionsForUser\", error);\n        }\n    };\n\n    /**\n     * Atomically updates session `title` + `updated_at`.\n     */\n    updateSessionTitle = async (elphieSessionId: string, title: string): Promise<ElphieSession> => {\n        try {\n            const updated = await ElphieSessionModel.update(\n                { elphieSessionId },\n                {\n                    title,\n                    updated_at: nowIso()\n                },\n                {\n                    condition: new dynamoose.Condition().attribute(\"elphieSessionId\").exists()\n                }\n            );\n            return updated as unknown as ElphieSession;\n        } catch (error) {\n            if (isNotFoundError(error) || isConditionalCheckFailed(error)) {\n                throw new SessionNotFoundError(elphieSessionId);\n            }\n            throw wrapUnexpected(\"updateSessionTitle\", error);\n        }\n    };\n}\n\nconst isNotFoundError = (error: unknown): boolean => {\n    const name = (error as { name?: string } | null)?.name;\n    return name === \"ItemNotFoundException\" || name === \"ItemNotFoundError\";\n};\n\nconst isConditionalCheckFailed = (error: unknown): boolean => {\n    const name = (error as { name?: string } | null)?.name;\n    return name === \"ConditionalCheckFailedException\";\n};\n\nconst wrapUnexpected = (operation: string, error: unknown): Error => {\n    const message = error instanceof Error ? error.message : String(error);\n    return new Error(`ElphieSessionService.${operation} failed: ${message}`);\n};\n\nexport const elphieSessionService = new ElphieSessionService();\n"]}