@molecule/api-resource-journal-entry 1.0.0

package/LICENSE

@@ -0,0 +1,115 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work.
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship.
+
+      "Contribution" shall mean any work of authorship, including the
+      original version of the Work and any modifications or additions
+      to that Work, that is intentionally submitted to the Licensor for
+      inclusion in the Work by the copyright owner or by an individual or
+      Legal Entity authorized to submit on behalf of the copyright owner.
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by the Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      patent license to make, have made, use, offer to sell, sell, import,
+      and otherwise transfer the Work.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file.
+
+   5. Submission of Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND.
+
+   8. Limitation of Liability. In no event and under no legal theory shall
+      any Contributor be liable to You for damages.
+
+   9. Accepting Warranty or Additional Liability.
+
+   Copyright 2026 Molecule Dev, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/dist/browser-guard.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=browser-guard.d.ts.map

package/dist/browser-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-guard.d.ts","sourceRoot":"","sources":["../src/browser-guard.ts"],"names":[],"mappings":"AAuBA,OAAO,EAAE,CAAA"}

package/dist/browser-guard.js

@@ -0,0 +1,18 @@
+/**
+ * Browser guard — `@molecule/api-resource-journal-entry` is SERVER-ONLY.
+ *
+ * Generated by scripts/gen-browser-guards.mjs (workspace root) — edit THAT, not this.
+ * Evaluating a server package in a browser bundle is always an import-graph mistake
+ * (node APIs, secrets); without this guard it surfaces as a cryptic downstream crash
+ * ("Buffer is not defined") far from the culprit. Throwing here names the package and
+ * the fix at the exact moment the client bundle evaluates it. jsdom tests and SSR are
+ * unaffected: the throw requires browser globals AND the absence of a node runtime.
+ */
+const g = globalThis;
+if (g.window !== undefined && g.document !== undefined && !g.process?.versions?.node) {
+    throw new Error('@molecule/api-resource-journal-entry is SERVER-ONLY: it was bundled into browser/client code. Import it only ' +
+        'from server code (a server route/function or your API), or dynamic-import it inside ' +
+        'the server handler — never from components or shared client modules, and never ' +
+        'polyfill Buffer/process to silence this.');
+}
+export {};

package/dist/index.d.ts

@@ -0,0 +1,61 @@
+/**
+ * `@molecule/api-resource-journal-entry` — owner-scoped diary entries
+ * with optional at-rest encryption, mood-score linkage, daily-write
+ * streaks, and JSON/CSV/TXT export.
+ *
+ * Extracted from the mental-health-journal flagship. When
+ * `@molecule/api-encryption` is bonded, entry bodies are stored
+ * encrypted-at-rest; otherwise the plaintext column is used (the read
+ * path falls back automatically so key rotation never bricks reads).
+ *
+ * @example
+ * ```ts
+ * import { createJournalEntryRouter } from '@molecule/api-resource-journal-entry'
+ * import express from 'express'
+ *
+ * const app = express()
+ * app.use('/api/journal', createJournalEntryRouter())
+ * ```
+ *
+ * @remarks
+ * Schema lives in `__setup__/journal_entries.sql` — two tables:
+ * `journal_entries` + `mood_entries`. Mood rows are upserted per
+ * (user, day) so multiple entries in a day share one mood row.
+ *
+ * @e2e
+ * Integration checklist — drive the real UI (live preview, no mocks), adapt
+ * each item to this app's actual journal screens/flows, and check every box
+ * off one by one. A box you can't check is an integration bug to fix — not a
+ * skip. This is a PRIVATE journal, so privacy is the defining requirement:
+ * - [ ] Writing an entry persists its real fields — title, body, mood
+ *   (radiant/good/neutral/low/struggling), tags, and date (written_at) — and
+ *   the entry then appears in the author's journal list dated correctly (the
+ *   list is newest-first by written_at) with a word_count matching the body.
+ * - [ ] Editing an entry (title / body / mood / tags) and deleting one both
+ *   reflect in the UI immediately AND survive a reload — the change persisted
+ *   server-side, not just local state.
+ * - [ ] If the UI filters or searches the list (by tag, mood, or date), only
+ *   matching entries come back, and the mood shown per entry matches the mood
+ *   saved for that day (mood rows upsert once per user per day).
+ * - [ ] If a write streak or count is shown, it equals the number of
+ *   consecutive distinct days the author actually wrote, counted on the UTC
+ *   day boundary and ending today or yesterday — add or remove entries across
+ *   a day boundary and confirm it recomputes; a JSON/CSV/TXT export downloads
+ *   only the author's own entries.
+ * - [ ] PRIVACY / AUTHORIZATION — entries are visible ONLY to their author.
+ *   There is no sharing and no cross-user read path: signed in as a second
+ *   user, requesting another user's entry id returns 404 (not-owned and truly
+ *   missing are indistinguishable, so existence is never leaked), and the list
+ *   and export return only your own rows — no admin or global view surfaces
+ *   another user's entries. The owner is always the session user, never a
+ *   userId taken from the request body, and journal content is never written
+ *   to logs in the clear.
+ *
+ * @module
+ */
+export * from './browser-guard.js';
+export * from './routes.js';
+export * from './service.js';
+export * from './types.js';
+export * from './validation.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AAEH,cAAc,oBAAoB,CAAA;AAClC,cAAc,aAAa,CAAA;AAC3B,cAAc,cAAc,CAAA;AAC5B,cAAc,YAAY,CAAA;AAC1B,cAAc,iBAAiB,CAAA"}

package/dist/index.js

@@ -0,0 +1,60 @@
+/**
+ * `@molecule/api-resource-journal-entry` — owner-scoped diary entries
+ * with optional at-rest encryption, mood-score linkage, daily-write
+ * streaks, and JSON/CSV/TXT export.
+ *
+ * Extracted from the mental-health-journal flagship. When
+ * `@molecule/api-encryption` is bonded, entry bodies are stored
+ * encrypted-at-rest; otherwise the plaintext column is used (the read
+ * path falls back automatically so key rotation never bricks reads).
+ *
+ * @example
+ * ```ts
+ * import { createJournalEntryRouter } from '@molecule/api-resource-journal-entry'
+ * import express from 'express'
+ *
+ * const app = express()
+ * app.use('/api/journal', createJournalEntryRouter())
+ * ```
+ *
+ * @remarks
+ * Schema lives in `__setup__/journal_entries.sql` — two tables:
+ * `journal_entries` + `mood_entries`. Mood rows are upserted per
+ * (user, day) so multiple entries in a day share one mood row.
+ *
+ * @e2e
+ * Integration checklist — drive the real UI (live preview, no mocks), adapt
+ * each item to this app's actual journal screens/flows, and check every box
+ * off one by one. A box you can't check is an integration bug to fix — not a
+ * skip. This is a PRIVATE journal, so privacy is the defining requirement:
+ * - [ ] Writing an entry persists its real fields — title, body, mood
+ *   (radiant/good/neutral/low/struggling), tags, and date (written_at) — and
+ *   the entry then appears in the author's journal list dated correctly (the
+ *   list is newest-first by written_at) with a word_count matching the body.
+ * - [ ] Editing an entry (title / body / mood / tags) and deleting one both
+ *   reflect in the UI immediately AND survive a reload — the change persisted
+ *   server-side, not just local state.
+ * - [ ] If the UI filters or searches the list (by tag, mood, or date), only
+ *   matching entries come back, and the mood shown per entry matches the mood
+ *   saved for that day (mood rows upsert once per user per day).
+ * - [ ] If a write streak or count is shown, it equals the number of
+ *   consecutive distinct days the author actually wrote, counted on the UTC
+ *   day boundary and ending today or yesterday — add or remove entries across
+ *   a day boundary and confirm it recomputes; a JSON/CSV/TXT export downloads
+ *   only the author's own entries.
+ * - [ ] PRIVACY / AUTHORIZATION — entries are visible ONLY to their author.
+ *   There is no sharing and no cross-user read path: signed in as a second
+ *   user, requesting another user's entry id returns 404 (not-owned and truly
+ *   missing are indistinguishable, so existence is never leaked), and the list
+ *   and export return only your own rows — no admin or global view surfaces
+ *   another user's entries. The owner is always the session user, never a
+ *   userId taken from the request body, and journal content is never written
+ *   to logs in the clear.
+ *
+ * @module
+ */
+export * from './browser-guard.js';
+export * from './routes.js';
+export * from './service.js';
+export * from './types.js';
+export * from './validation.js';

package/dist/routes.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Express router factory for the journal-entry resource. Mount at any
+ * path (e.g. `/api/journal`).
+ *
+ * @module
+ */
+import { Router } from 'express';
+/** Build the journal-entry router. */
+export declare function createJournalEntryRouter(): Router;
+//# sourceMappingURL=routes.d.ts.map

package/dist/routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../src/routes.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAA+B,MAAM,EAAE,MAAM,SAAS,CAAA;AAiD7D,sCAAsC;AACtC,wBAAgB,wBAAwB,IAAI,MAAM,CAkHjD"}

package/dist/routes.js

@@ -0,0 +1,150 @@
+/**
+ * Express router factory for the journal-entry resource. Mount at any
+ * path (e.g. `/api/journal`).
+ *
+ * @module
+ */
+import { Router } from 'express';
+import { getUserId, idParamSchema } from '@molecule/api-bonds-default-express';
+import { t } from '@molecule/api-i18n';
+import { logger } from '@molecule/api-logger';
+import { validateBody as validateBodyRaw, validateParams, } from '@molecule/api-middleware-validation';
+import { computeStreak, createEntryForOwner, deleteEntryForOwner, exportEntries, formatExport, getEntryForOwner, listEntriesForOwner, updateEntryForOwner, } from './service.js';
+import { createEntrySchema, updateEntrySchema } from './validation.js';
+const validateBody = validateBodyRaw;
+const EXPORT_FORMATS = ['json', 'csv', 'txt'];
+/** Returns a 401 Unauthorized JSON response. */
+function unauthorized(res) {
+    return res
+        .status(401)
+        .json({ error: t('auth.unauthorized', undefined, { defaultValue: 'Unauthorized' }) });
+}
+/** Returns a 404 Not Found JSON response for a missing journal entry. */
+function notFound(res) {
+    return res.status(404).json({
+        error: t('journal.notFound', undefined, { defaultValue: 'Journal entry not found' }),
+    });
+}
+/** Returns a 500 Internal Server Error JSON response. */
+function internalError(res) {
+    return res.status(500).json({
+        error: t('errors.internalServer', undefined, { defaultValue: 'Internal server error' }),
+    });
+}
+/** Build the journal-entry router. */
+export function createJournalEntryRouter() {
+    const router = Router();
+    router.get('/entries', async (req, res) => {
+        const userId = getUserId(res);
+        if (!userId)
+            return unauthorized(res);
+        try {
+            const limit = Math.max(1, Math.min(200, Number(req.query.limit) || 100));
+            res.json(await listEntriesForOwner(userId, limit));
+        }
+        catch (error) {
+            logger.error('listEntriesForOwner failed', { error });
+            internalError(res);
+        }
+    });
+    router.get('/entries/:id', validateParams(idParamSchema), async (req, res) => {
+        const userId = getUserId(res);
+        if (!userId)
+            return unauthorized(res);
+        try {
+            const entry = await getEntryForOwner(userId, String(req.params.id));
+            if (!entry)
+                return notFound(res);
+            res.json(entry);
+        }
+        catch (error) {
+            logger.error('getEntryForOwner failed', { error });
+            internalError(res);
+        }
+    });
+    router.post('/entries', validateBody(createEntrySchema), async (req, res) => {
+        const userId = getUserId(res);
+        if (!userId)
+            return unauthorized(res);
+        try {
+            const body = req.body;
+            const created = await createEntryForOwner(userId, body);
+            if (!created)
+                return internalError(res);
+            res.status(201).json(created);
+        }
+        catch (error) {
+            logger.error('createEntryForOwner failed', { error });
+            internalError(res);
+        }
+    });
+    router.put('/entries/:id', validateParams(idParamSchema), validateBody(updateEntrySchema), async (req, res) => {
+        const userId = getUserId(res);
+        if (!userId)
+            return unauthorized(res);
+        try {
+            const body = req.body;
+            const updated = await updateEntryForOwner(userId, String(req.params.id), body);
+            if (!updated)
+                return notFound(res);
+            res.json(updated);
+        }
+        catch (error) {
+            logger.error('updateEntryForOwner failed', { error });
+            internalError(res);
+        }
+    });
+    router.delete('/entries/:id', validateParams(idParamSchema), async (req, res) => {
+        const userId = getUserId(res);
+        if (!userId)
+            return unauthorized(res);
+        try {
+            const ok = await deleteEntryForOwner(userId, String(req.params.id));
+            if (!ok)
+                return notFound(res);
+            res.status(204).end();
+        }
+        catch (error) {
+            logger.error('deleteEntryForOwner failed', { error });
+            internalError(res);
+        }
+    });
+    router.get('/streak', async (_req, res) => {
+        const userId = getUserId(res);
+        if (!userId)
+            return unauthorized(res);
+        try {
+            res.json({ streak: await computeStreak(userId) });
+        }
+        catch (error) {
+            logger.error('computeStreak failed', { error });
+            internalError(res);
+        }
+    });
+    router.get('/export/:format', async (req, res) => {
+        const userId = getUserId(res);
+        if (!userId)
+            return unauthorized(res);
+        try {
+            const format = String(req.params.format).toLowerCase();
+            if (!EXPORT_FORMATS.includes(format)) {
+                return res.status(400).json({
+                    error: t('journal.invalidExportFormat', undefined, {
+                        defaultValue: 'Unsupported export format.',
+                    }),
+                });
+            }
+            const records = await exportEntries(userId);
+            const { contentType, body } = formatExport(records, format);
+            const stamp = new Date().toISOString().slice(0, 10);
+            res.setHeader('Content-Type', contentType);
+            res.setHeader('Content-Disposition', `attachment; filename="journal-${stamp}.${format}"`);
+            res.end(body);
+        }
+        catch (error) {
+            logger.error('exportEntries failed', { error });
+            internalError(res);
+        }
+    });
+    return router;
+}

package/dist/service.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Pure service-layer helpers for the journal-entry resource. Usable
+ * outside of HTTP contexts (background jobs, exports, AI pipelines).
+ *
+ * @module
+ */
+import { type JournalEntryRow, type MoodLevel, type PublicJournalEntry } from './types.js';
+/** Decrypt the entry body if encryption is bonded; otherwise return plaintext. */
+export declare function decryptIfNeeded(row: JournalEntryRow): Promise<string>;
+/** Shape a row into the public-facing representation. */
+export declare function shapeEntry(entry: JournalEntryRow, body: string): Promise<PublicJournalEntry>;
+/** List the most-recent entries for an owner. */
+export declare function listEntriesForOwner(userId: string, limit?: number): Promise<PublicJournalEntry[]>;
+/** Owner-scoped read — returns null when missing or not owned. */
+export declare function getEntryForOwner(userId: string, id: string): Promise<PublicJournalEntry | null>;
+/** Input fields accepted when creating a new journal entry. */
+export interface CreateEntryInput {
+    mood?: MoodLevel;
+    title?: string;
+    body: string;
+    tags?: string[];
+    prompt_id?: string | null;
+    written_at?: string | Date;
+}
+/**
+ * Create a journal entry and, if `mood` is provided, upsert today's
+ * `mood_entries` row + link it to the journal entry.
+ */
+export declare function createEntryForOwner(userId: string, input: CreateEntryInput): Promise<PublicJournalEntry | null>;
+/** Fields that can be patched on an existing journal entry. */
+export interface UpdateEntryInput {
+    mood?: MoodLevel;
+    title?: string;
+    body?: string;
+    tags?: string[];
+}
+/** Owner-scoped patch update — returns null when missing or not owned. */
+export declare function updateEntryForOwner(userId: string, id: string, input: UpdateEntryInput): Promise<PublicJournalEntry | null>;
+/** Owner-scoped delete — true if it deleted, false if not owned / missing. */
+export declare function deleteEntryForOwner(userId: string, id: string): Promise<boolean>;
+/** Daily-write streak: consecutive distinct UTC days ending today/yesterday. */
+export declare function computeStreak(userId: string): Promise<number>;
+/** Flattened, export-friendly representation of a single journal entry. */
+export interface ExportRecord {
+    id: string;
+    date: string;
+    title: string;
+    mood: MoodLevel;
+    tags: string[];
+    word_count: number;
+    body: string;
+}
+/** Serialize all entries for an owner into an export-friendly array. */
+export declare function exportEntries(userId: string, max?: number): Promise<ExportRecord[]>;
+/** Format export records as JSON / CSV / TXT. */
+export declare function formatExport(records: ExportRecord[], format: 'json' | 'csv' | 'txt'): {
+    contentType: string;
+    body: string;
+};
+//# sourceMappingURL=service.d.ts.map

package/dist/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,OAAO,EACL,KAAK,eAAe,EAGpB,KAAK,SAAS,EACd,KAAK,kBAAkB,EAExB,MAAM,YAAY,CAAA;AAiCnB,kFAAkF;AAClF,wBAAsB,eAAe,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC,CAS3E;AAWD,yDAAyD;AACzD,wBAAsB,UAAU,CAC9B,KAAK,EAAE,eAAe,EACtB,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,kBAAkB,CAAC,CAc7B;AAED,iDAAiD;AACjD,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,MAAM,EACd,KAAK,SAAM,GACV,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAS/B;AAED,kEAAkE;AAClE,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,MAAM,EACd,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAIpC;AAED,+DAA+D;AAC/D,MAAM,WAAW,gBAAgB;IAC/B,IAAI,CAAC,EAAE,SAAS,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;IACf,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAC3B;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,gBAAgB,GACtB,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CA2DpC;AAED,+DAA+D;AAC/D,MAAM,WAAW,gBAAgB;IAC/B,IAAI,CAAC,EAAE,SAAS,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;CAChB;AAED,0EAA0E;AAC1E,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,MAAM,EACd,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,gBAAgB,GACtB,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAgCpC;AAED,8EAA8E;AAC9E,wBAAsB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAKtF;AAED,gFAAgF;AAChF,wBAAsB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CA0BnE;AAED,2EAA2E;AAC3E,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,SAAS,CAAA;IACf,IAAI,EAAE,MAAM,EAAE,CAAA;IACd,UAAU,EAAE,MAAM,CAAA;IAClB,IAAI,EAAE,MAAM,CAAA;CACb;AAED,wEAAwE;AACxE,wBAAsB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,SAAS,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAkBzF;AASD,iDAAiD;AACjD,wBAAgB,YAAY,CAC1B,OAAO,EAAE,YAAY,EAAE,EACvB,MAAM,EAAE,MAAM,GAAG,KAAK,GAAG,KAAK,GAC7B;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CA+BvC"}

package/dist/service.js

@@ -0,0 +1,291 @@
+/**
+ * Pure service-layer helpers for the journal-entry resource. Usable
+ * outside of HTTP contexts (background jobs, exports, AI pipelines).
+ *
+ * @module
+ */
+import { create, deleteById, findById, findMany, query, updateById } from '@molecule/api-database';
+import { decrypt, encrypt, hasProvider as hasEncryption } from '@molecule/api-encryption';
+import { levelByScore, SCORE_BY_LEVEL, } from './types.js';
+const TABLE = 'journal_entries';
+const MOOD_TABLE = 'mood_entries';
+/** Coerce a date-like value to an ISO-8601 string, defaulting to now. */
+function toIso(d) {
+    if (!d)
+        return new Date().toISOString();
+    return new Date(d).toISOString();
+}
+/** Parse a JSON string into a typed array, returning `[]` on invalid input. */
+function toJsonArray(raw) {
+    if (Array.isArray(raw))
+        return raw;
+    if (typeof raw === 'string') {
+        try {
+            const parsed = JSON.parse(raw);
+            return Array.isArray(parsed) ? parsed : [];
+        }
+        catch (_error) {
+            // raw is not valid JSON — safe to return an empty array
+            return [];
+        }
+    }
+    return [];
+}
+/** Trim an entry body to a 200-character preview, collapsing whitespace. */
+function previewText(body) {
+    const collapsed = body.replace(/\s+/g, ' ').trim();
+    if (collapsed.length <= 200)
+        return collapsed;
+    return collapsed.slice(0, 197) + '…';
+}
+/** Decrypt the entry body if encryption is bonded; otherwise return plaintext. */
+export async function decryptIfNeeded(row) {
+    if (row.body_encrypted && hasEncryption()) {
+        try {
+            return await decrypt(row.body_encrypted, row.user_id);
+        }
+        catch (_error) {
+            // Decryption failed — fall back to the plaintext column so the entry remains readable
+        }
+    }
+    return row.body ?? '';
+}
+/** Resolve the mood level for a journal entry by looking up its linked mood row. */
+async function moodLevelForEntry(entry) {
+    if (entry.mood_id) {
+        const mood = await findById(MOOD_TABLE, entry.mood_id);
+        if (mood)
+            return levelByScore(mood.score);
+    }
+    return 'neutral';
+}
+/** Shape a row into the public-facing representation. */
+export async function shapeEntry(entry, body) {
+    return {
+        id: entry.id,
+        date: toIso(entry.written_at),
+        title: entry.title ?? '',
+        preview: previewText(body),
+        body,
+        mood: await moodLevelForEntry(entry),
+        tags: toJsonArray(entry.tags),
+        word_count: entry.word_count,
+        ai_summary: entry.ai_summary,
+        ai_themes: toJsonArray(entry.ai_themes),
+        prompt: entry.prompt_id,
+    };
+}
+/** List the most-recent entries for an owner. */
+export async function listEntriesForOwner(userId, limit = 100) {
+    const rows = await findMany(TABLE, {
+        where: [{ field: 'user_id', operator: '=', value: userId }],
+        orderBy: [{ field: 'written_at', direction: 'desc' }],
+        limit,
+    });
+    const out = [];
+    for (const row of rows)
+        out.push(await shapeEntry(row, await decryptIfNeeded(row)));
+    return out;
+}
+/** Owner-scoped read — returns null when missing or not owned. */
+export async function getEntryForOwner(userId, id) {
+    const row = await findById(TABLE, id);
+    if (!row || row.user_id !== userId)
+        return null;
+    return shapeEntry(row, await decryptIfNeeded(row));
+}
+/**
+ * Create a journal entry and, if `mood` is provided, upsert today's
+ * `mood_entries` row + link it to the journal entry.
+ */
+export async function createEntryForOwner(userId, input) {
+    let moodId = null;
+    if (input.mood) {
+        const score = SCORE_BY_LEVEL[input.mood];
+        const sameDay = await query(`SELECT id FROM ${MOOD_TABLE}
+         WHERE user_id = $1 AND recorded_at::date = NOW()::date
+         ORDER BY recorded_at DESC LIMIT 1`, [userId]);
+        if (sameDay.rows.length > 0) {
+            moodId = sameDay.rows[0].id;
+            await updateById(MOOD_TABLE, moodId, { score, label: input.mood });
+        }
+        else {
+            const created = await create(MOOD_TABLE, {
+                user_id: userId,
+                score,
+                label: input.mood,
+                activities: '[]',
+                recorded_at: new Date(),
+                created_at: new Date(),
+            });
+            moodId = created.data?.id ?? null;
+        }
+    }
+    const writtenAt = input.written_at ? new Date(input.written_at) : new Date();
+    const wordCount = input.body.split(/\s+/).filter(Boolean).length;
+    let bodyEncrypted = null;
+    if (hasEncryption()) {
+        bodyEncrypted = await encrypt(input.body, userId);
+    }
+    const result = await create(TABLE, {
+        user_id: userId,
+        title: input.title ?? null,
+        body: input.body,
+        body_encrypted: bodyEncrypted,
+        body_iv: null,
+        mood_id: moodId,
+        prompt_id: input.prompt_id ?? null,
+        activity_ids: '[]',
+        tags: JSON.stringify(input.tags ?? []),
+        word_count: wordCount,
+        ai_summary: null,
+        ai_themes: null,
+        is_private: true,
+        written_at: writtenAt,
+        created_at: new Date(),
+    });
+    const entryId = result.data?.id ?? null;
+    if (moodId && entryId) {
+        await updateById(MOOD_TABLE, moodId, { journal_entry_id: entryId });
+    }
+    if (!entryId)
+        return null;
+    const full = await findById(TABLE, entryId);
+    if (!full)
+        return null;
+    return shapeEntry(full, await decryptIfNeeded(full));
+}
+/** Owner-scoped patch update — returns null when missing or not owned. */
+export async function updateEntryForOwner(userId, id, input) {
+    const existing = await findById(TABLE, id);
+    if (!existing || existing.user_id !== userId)
+        return null;
+    const patch = { updated_at: new Date() };
+    if (input.title !== undefined)
+        patch.title = input.title;
+    if (input.body !== undefined) {
+        patch.body = input.body;
+        patch.word_count = input.body.split(/\s+/).filter(Boolean).length;
+        if (hasEncryption())
+            patch.body_encrypted = await encrypt(input.body, userId);
+    }
+    if (input.tags !== undefined)
+        patch.tags = JSON.stringify(input.tags);
+    if (input.mood) {
+        const score = SCORE_BY_LEVEL[input.mood];
+        if (existing.mood_id) {
+            await updateById(MOOD_TABLE, existing.mood_id, { score, label: input.mood });
+        }
+        else {
+            const created = await create(MOOD_TABLE, {
+                user_id: userId,
+                score,
+                label: input.mood,
+                activities: '[]',
+                recorded_at: new Date(),
+                created_at: new Date(),
+                journal_entry_id: id,
+            });
+            patch.mood_id = created.data?.id ?? null;
+        }
+    }
+    await updateById(TABLE, id, patch);
+    const updated = await findById(TABLE, id);
+    if (!updated)
+        return null;
+    return shapeEntry(updated, await decryptIfNeeded(updated));
+}
+/** Owner-scoped delete — true if it deleted, false if not owned / missing. */
+export async function deleteEntryForOwner(userId, id) {
+    const existing = await findById(TABLE, id);
+    if (!existing || existing.user_id !== userId)
+        return false;
+    await deleteById(TABLE, id);
+    return true;
+}
+/** Daily-write streak: consecutive distinct UTC days ending today/yesterday. */
+export async function computeStreak(userId) {
+    const { rows } = await query(`SELECT DISTINCT to_char(written_at AT TIME ZONE 'UTC', 'YYYY-MM-DD') AS day
+       FROM ${TABLE}
+       WHERE user_id = $1
+       ORDER BY day DESC
+       LIMIT 365`, [userId]);
+    if (rows.length === 0)
+        return 0;
+    const set = new Set(rows.map((r) => r.day));
+    let streak = 0;
+    const cursor = new Date();
+    cursor.setUTCHours(0, 0, 0, 0);
+    for (let i = 0; i < 365; i++) {
+        const iso = cursor.toISOString().slice(0, 10);
+        if (set.has(iso)) {
+            streak++;
+            cursor.setUTCDate(cursor.getUTCDate() - 1);
+        }
+        else if (i === 0) {
+            cursor.setUTCDate(cursor.getUTCDate() - 1);
+        }
+        else {
+            break;
+        }
+    }
+    return streak;
+}
+/** Serialize all entries for an owner into an export-friendly array. */
+export async function exportEntries(userId, max = 10_000) {
+    const entries = await findMany(TABLE, {
+        where: [{ field: 'user_id', operator: '=', value: userId }],
+        orderBy: [{ field: 'written_at', direction: 'desc' }],
+        limit: max,
+    });
+    const decrypted = await Promise.all(entries.map((entry) => decryptIfNeeded(entry)));
+    return Promise.all(entries.map(async (entry, i) => ({
+        id: entry.id,
+        date: toIso(entry.written_at),
+        title: entry.title ?? '',
+        mood: await moodLevelForEntry(entry),
+        tags: toJsonArray(entry.tags),
+        word_count: entry.word_count,
+        body: decrypted[i],
+    })));
+}
+/** Escape a value for inclusion in a CSV cell, quoting if necessary. */
+function csvEscape(v) {
+    const s = v == null ? '' : String(v);
+    if (/[",\n\r]/.test(s))
+        return `"${s.replace(/"/g, '""')}"`;
+    return s;
+}
+/** Format export records as JSON / CSV / TXT. */
+export function formatExport(records, format) {
+    if (format === 'json') {
+        return {
+            contentType: 'application/json; charset=utf-8',
+            body: JSON.stringify({ exported_at: new Date().toISOString(), records }, null, 2),
+        };
+    }
+    if (format === 'csv') {
+        const headers = ['id', 'date', 'title', 'mood', 'tags', 'word_count', 'body'];
+        const lines = [headers.join(',')];
+        for (const r of records) {
+            lines.push([r.id, r.date, r.title, r.mood, r.tags.join('|'), String(r.word_count), r.body]
+                .map(csvEscape)
+                .join(','));
+        }
+        return { contentType: 'text/csv; charset=utf-8', body: lines.join('\n') };
+    }
+    const out = [`Journal export — ${new Date().toISOString()}`, ''];
+    for (const r of records) {
+        out.push(`# ${r.date}  •  ${r.mood.toUpperCase()}`);
+        if (r.title)
+            out.push(`## ${r.title}`);
+        out.push('');
+        out.push(r.body);
+        if (r.tags.length > 0)
+            out.push(`Tags: ${r.tags.join(', ')}`);
+        out.push('');
+        out.push('-----');
+        out.push('');
+    }
+    return { contentType: 'text/plain; charset=utf-8', body: out.join('\n') };
+}

package/dist/types.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Shared types for the journal-entry resource.
+ *
+ * @module
+ */
+/** Discrete mood-level labels mapped to a 1..5 score. */
+export type MoodLevel = 'radiant' | 'good' | 'neutral' | 'low' | 'struggling';
+/** Row shape persisted in `journal_entries`. */
+export interface JournalEntryRow {
+    id: string;
+    user_id: string;
+    written_at: string | Date;
+    title: string | null;
+    body: string | null;
+    body_encrypted: string | null;
+    body_iv: string | null;
+    mood_id: string | null;
+    prompt_id: string | null;
+    activity_ids: unknown;
+    tags: unknown;
+    word_count: number;
+    ai_summary: string | null;
+    ai_themes: unknown;
+    is_private: boolean;
+    created_at: string | Date;
+}
+/** Row shape persisted in `mood_entries`. */
+export interface MoodEntryRow {
+    id: string;
+    user_id: string;
+    recorded_at: string | Date;
+    score: number;
+    energy: number | null;
+    anxiety: number | null;
+    label: string | null;
+    activities: unknown;
+    notes: string | null;
+    journal_entry_id: string | null;
+    created_at: string | Date;
+}
+/** Public-facing decrypted entry (returned by the service / routes). */
+export interface PublicJournalEntry {
+    id: string;
+    date: string;
+    title: string;
+    preview: string;
+    body: string;
+    mood: MoodLevel;
+    tags: string[];
+    word_count: number;
+    ai_summary: string | null;
+    ai_themes: string[];
+    prompt: string | null;
+}
+/** Maps each MoodLevel label to its corresponding numeric score (1..5). */
+export declare const SCORE_BY_LEVEL: Record<MoodLevel, number>;
+/** Round + clamp a raw score and return its discrete label. */
+export declare function levelByScore(score: number | null | undefined): MoodLevel;
+/** Normalize a 1..5 score to 0..1 (useful for sparkline charts). */
+export declare function normalizeScore(score: number | null | undefined): number;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,yDAAyD;AACzD,MAAM,MAAM,SAAS,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,GAAG,KAAK,GAAG,YAAY,CAAA;AAE7E,gDAAgD;AAChD,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAA;IACV,OAAO,EAAE,MAAM,CAAA;IACf,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACnB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7B,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,YAAY,EAAE,OAAO,CAAA;IACrB,IAAI,EAAE,OAAO,CAAA;IACb,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,SAAS,EAAE,OAAO,CAAA;IAClB,UAAU,EAAE,OAAO,CAAA;IACnB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;CAC1B;AAED,6CAA6C;AAC7C,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAA;IACV,OAAO,EAAE,MAAM,CAAA;IACf,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;IACrB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB,UAAU,EAAE,OAAO,CAAA;IACnB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAA;IAC/B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;CAC1B;AAED,wEAAwE;AACxE,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,SAAS,CAAA;IACf,IAAI,EAAE,MAAM,EAAE,CAAA;IACd,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;CACtB;AAED,2EAA2E;AAC3E,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,CAMpD,CAAA;AAED,+DAA+D;AAC/D,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,SAAS,CAGxE;AAED,oEAAoE;AACpE,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAGvE"}

package/dist/types.js

@@ -0,0 +1,24 @@
+/**
+ * Shared types for the journal-entry resource.
+ *
+ * @module
+ */
+/** Maps each MoodLevel label to its corresponding numeric score (1..5). */
+export const SCORE_BY_LEVEL = {
+    radiant: 5,
+    good: 4,
+    neutral: 3,
+    low: 2,
+    struggling: 1,
+};
+/** Round + clamp a raw score and return its discrete label. */
+export function levelByScore(score) {
+    const n = Math.max(1, Math.min(5, Math.round(Number(score ?? 3))));
+    return ['struggling', 'low', 'neutral', 'good', 'radiant'][n - 1];
+}
+/** Normalize a 1..5 score to 0..1 (useful for sparkline charts). */
+export function normalizeScore(score) {
+    if (score == null)
+        return 0.5;
+    return Math.max(0, Math.min(1, (Number(score) - 1) / 4));
+}

package/dist/validation.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Zod schemas for journal-entry create / update payloads.
+ *
+ * @module
+ */
+import { z } from 'zod';
+/** Mood level enum used by journal-entry payloads. */
+export declare const moodLevelSchema: z.ZodEnum<{
+    radiant: "radiant";
+    good: "good";
+    neutral: "neutral";
+    low: "low";
+    struggling: "struggling";
+}>;
+/** Validator for creating a new journal entry. */
+export declare const createEntrySchema: z.ZodObject<{
+    mood: z.ZodOptional<z.ZodEnum<{
+        radiant: "radiant";
+        good: "good";
+        neutral: "neutral";
+        low: "low";
+        struggling: "struggling";
+    }>>;
+    title: z.ZodOptional<z.ZodString>;
+    body: z.ZodString;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    prompt_id: z.ZodOptional<z.ZodString>;
+    written_at: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** Validator for updating an existing journal entry. */
+export declare const updateEntrySchema: z.ZodObject<{
+    mood: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
+        radiant: "radiant";
+        good: "good";
+        neutral: "neutral";
+        low: "low";
+        struggling: "struggling";
+    }>>>;
+    title: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    tags: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    prompt_id: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    written_at: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    body: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+//# sourceMappingURL=validation.d.ts.map

package/dist/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,sDAAsD;AACtD,eAAO,MAAM,eAAe;;;;;;EAAsB,CAAA;AAElD,kDAAkD;AAClD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;iBAO5B,CAAA;AAEF,wDAAwD;AACxD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;iBAE5B,CAAA"}

package/dist/validation.js

@@ -0,0 +1,22 @@
+/**
+ * Zod schemas for journal-entry create / update payloads.
+ *
+ * @module
+ */
+import { z } from 'zod';
+const MOOD_VALUES = ['radiant', 'good', 'neutral', 'low', 'struggling'];
+/** Mood level enum used by journal-entry payloads. */
+export const moodLevelSchema = z.enum(MOOD_VALUES);
+/** Validator for creating a new journal entry. */
+export const createEntrySchema = z.object({
+    mood: moodLevelSchema.optional(),
+    title: z.string().max(240).optional(),
+    body: z.string().min(1).max(50_000),
+    tags: z.array(z.string().min(1).max(64)).max(50).optional(),
+    prompt_id: z.string().uuid().optional(),
+    written_at: z.string().optional(),
+});
+/** Validator for updating an existing journal entry. */
+export const updateEntrySchema = createEntrySchema.partial().extend({
+    body: z.string().min(1).max(50_000).optional(),
+});

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@molecule/api-resource-journal-entry",
+  "version": "1.0.0",
+  "description": "Owner-scoped journal entry resource with optional at-rest encryption, mood linkage, daily streaks, and JSON/CSV/TXT export. Extracted from mental-health-journal flagship.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "molecule",
+    "journal",
+    "diary",
+    "mood",
+    "encryption",
+    "resource"
+  ],
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "@types/express": "5.0.6",
+    "@types/node": "26.1.2",
+    "express": "5.2.1",
+    "typescript": "6.0.3",
+    "vitest": "4.1.10",
+    "zod": "4.4.3"
+  },
+  "peerDependencies": {
+    "@molecule/api-bonds-default-express": "^1.0.0",
+    "@molecule/api-logger": "^1.0.0",
+    "@molecule/api-database": "^1.0.0",
+    "@molecule/api-encryption": "^1.0.0",
+    "@molecule/api-i18n": "^1.0.0",
+    "@molecule/api-middleware-validation": "^1.0.0",
+    "express": "^5.0.0",
+    "zod": "^4.0.0"
+  }
+}