@entifix/next-shell 0.1.0-0

package/dist/lib/crud/use-entity-bulk.js

@@ -0,0 +1,106 @@
+'use client';
+import { emptySelection } from '@entifix/core';
+import { useCallback, useState } from 'react';
+/**
+ * The code a row carries when the *request* failed rather than the row.
+ *
+ * `unexpected` is the shared fallback the `errors` catalog already ships, and
+ * it is the honest label: what went wrong is not something this row did.
+ */ const BULK_REQUEST_FAILED = 'unexpected';
+/**
+ * Owns a listing's selection and the result of the last bulk run.
+ *
+ * The selection lives here rather than inside `EntityTable` because it has to
+ * survive pagination, and the page owns the pager — a selection reset by the
+ * very navigation used to add to it would make "select rows across pages"
+ * impossible.
+ *
+ * Two behaviours worth not re-deriving. **The selection survives the action**
+ * (#121): after a run the rows stay ticked, because the operator's next act is
+ * usually to retry the failures or to run a second verb on the same rows, and
+ * re-selecting forty rows to do it is the whole cost the bulk bar exists to
+ * remove. And **a retry re-runs only the failures**, as an `ids` selection
+ * built from the outcomes — never the original selection, which would redo the
+ * successful rows and, for a `matching` selection, re-resolve a filter whose
+ * answer has just changed underneath it.
+ */ export function useEntityBulk({ run, onCompleted, onError }) {
+    const [selection, setSelection] = useState(()=>emptySelection());
+    const [outcomes, setOutcomes] = useState(undefined);
+    const [isRunning, setRunning] = useState(false);
+    const execute = useCallback(async (key, target)=>{
+        // Unreachable through the UI: the handlers that call this are only
+        // exposed when `run` exists. It is here because a `useCallback` cannot
+        // be declared conditionally and TypeScript still has to narrow.
+        /* v8 ignore next */ if (!run) return;
+        setRunning(true);
+        // The previous result is cleared as the new run starts: leaving it up
+        // would show last run's failures beside this run's spinner, and they
+        // are not the same rows.
+        setOutcomes(undefined);
+        try {
+            setOutcomes(await run(key, target));
+        } catch (error) {
+            // The *request* failed — the network, a `403`, a `500` — which is not a
+            // per-row outcome. Caught rather than left to reject: `void execute(…)`
+            // at the call site would otherwise make every failed bulk run an
+            // unhandled promise rejection, which is invisible in the UI and noisy
+            // in the console.
+            //
+            // When the rows are known it is reported as every row failing, because
+            // that is what happened, and it reuses the surface that already
+            // attributes failures per row. A `matching` selection has no id list to
+            // attribute to — that is the whole point of the mode — so it reports
+            // nothing here and the error goes to the caller instead.
+            if (target.mode === 'ids') {
+                setOutcomes(// `Array.from`, never a spread — see `toWireSelection`: the loose
+                // SWC helper wraps a `Set` instead of iterating it.
+                Array.from(target.ids).map((id)=>({
+                        id,
+                        ok: false,
+                        code: BULK_REQUEST_FAILED
+                    })));
+            }
+            onError == null ? void 0 : onError(error);
+        } finally{
+            setRunning(false);
+            onCompleted == null ? void 0 : onCompleted();
+        }
+    }, [
+        run,
+        onCompleted,
+        onError
+    ]);
+    const [lastKey, setLastKey] = useState(undefined);
+    const onBulkUseCase = useCallback((key, target)=>{
+        setLastKey(key);
+        void execute(key, target);
+    }, [
+        execute
+    ]);
+    const onBulkRetry = useCallback((ids)=>{
+        if (lastKey === undefined) return;
+        void execute(lastKey, {
+            mode: 'ids',
+            ids: new Set(ids)
+        });
+    }, [
+        execute,
+        lastKey
+    ]);
+    if (!run) return {
+        tableProps: {}
+    };
+    return {
+        tableProps: {
+            selection,
+            onSelectionChange: setSelection,
+            onBulkUseCase,
+            bulkOutcomes: outcomes,
+            onBulkDismiss: ()=>setOutcomes(undefined),
+            onBulkRetry,
+            isBulkRunning: isRunning
+        }
+    };
+}
+
+//# sourceMappingURL=use-entity-bulk.js.map

package/dist/lib/crud/use-entity-bulk.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/crud/use-entity-bulk.ts"],"sourcesContent":["'use client';\n\nimport {\n  type BulkOutcome,\n  emptySelection,\n  type Entity,\n  type EntityId,\n  type EntitySelection,\n} from '@entifix/core';\nimport { useCallback, useState } from 'react';\n\n/**\n * The code a row carries when the *request* failed rather than the row.\n *\n * `unexpected` is the shared fallback the `errors` catalog already ships, and\n * it is the honest label: what went wrong is not something this row did.\n */\nconst BULK_REQUEST_FAILED = 'unexpected';\n\nexport interface UseEntityBulkOptions<TEntity extends Entity> {\n  /**\n   * Runs one `collection`-bound verb. Absent means this listing has no bulk\n   * actions, and no selection column is rendered at all.\n   */\n  readonly run?: (\n    key: string,\n    selection: EntitySelection<TEntity>,\n  ) => Promise<readonly BulkOutcome[]>;\n  /** Called after a run, so the listing can re-read the rows it just changed. */\n  readonly onCompleted?: () => void;\n  /** The whole request failed — a transport error, not a per-row outcome. */\n  readonly onError?: (error: unknown) => void;\n}\n\n/** The props {@link useEntityBulk} contributes to `EntityTable`. */\nexport interface EntityBulkTableProps<TEntity extends Entity> {\n  selection?: EntitySelection<TEntity>;\n  onSelectionChange?: (selection: EntitySelection<TEntity>) => void;\n  onBulkUseCase?: (key: string, selection: EntitySelection<TEntity>) => void;\n  bulkOutcomes?: readonly BulkOutcome[];\n  onBulkDismiss?: () => void;\n  onBulkRetry?: (ids: EntityId[]) => void;\n  isBulkRunning?: boolean;\n}\n\n/**\n * Owns a listing's selection and the result of the last bulk run.\n *\n * The selection lives here rather than inside `EntityTable` because it has to\n * survive pagination, and the page owns the pager — a selection reset by the\n * very navigation used to add to it would make \"select rows across pages\"\n * impossible.\n *\n * Two behaviours worth not re-deriving. **The selection survives the action**\n * (#121): after a run the rows stay ticked, because the operator's next act is\n * usually to retry the failures or to run a second verb on the same rows, and\n * re-selecting forty rows to do it is the whole cost the bulk bar exists to\n * remove. And **a retry re-runs only the failures**, as an `ids` selection\n * built from the outcomes — never the original selection, which would redo the\n * successful rows and, for a `matching` selection, re-resolve a filter whose\n * answer has just changed underneath it.\n */\nexport function useEntityBulk<TEntity extends Entity>({\n  run,\n  onCompleted,\n  onError,\n}: UseEntityBulkOptions<TEntity>): {\n  tableProps: EntityBulkTableProps<TEntity>;\n} {\n  const [selection, setSelection] = useState<EntitySelection<TEntity>>(() =>\n    emptySelection<TEntity>(),\n  );\n  const [outcomes, setOutcomes] = useState<readonly BulkOutcome[] | undefined>(\n    undefined,\n  );\n  const [isRunning, setRunning] = useState(false);\n\n  const execute = useCallback(\n    async (key: string, target: EntitySelection<TEntity>) => {\n      // Unreachable through the UI: the handlers that call this are only\n      // exposed when `run` exists. It is here because a `useCallback` cannot\n      // be declared conditionally and TypeScript still has to narrow.\n      /* v8 ignore next */\n      if (!run) return;\n      setRunning(true);\n      // The previous result is cleared as the new run starts: leaving it up\n      // would show last run's failures beside this run's spinner, and they\n      // are not the same rows.\n      setOutcomes(undefined);\n      try {\n        setOutcomes(await run(key, target));\n      } catch (error) {\n        // The *request* failed — the network, a `403`, a `500` — which is not a\n        // per-row outcome. Caught rather than left to reject: `void execute(…)`\n        // at the call site would otherwise make every failed bulk run an\n        // unhandled promise rejection, which is invisible in the UI and noisy\n        // in the console.\n        //\n        // When the rows are known it is reported as every row failing, because\n        // that is what happened, and it reuses the surface that already\n        // attributes failures per row. A `matching` selection has no id list to\n        // attribute to — that is the whole point of the mode — so it reports\n        // nothing here and the error goes to the caller instead.\n        if (target.mode === 'ids') {\n          setOutcomes(\n            // `Array.from`, never a spread — see `toWireSelection`: the loose\n            // SWC helper wraps a `Set` instead of iterating it.\n            Array.from(target.ids).map(id => ({\n              id,\n              ok: false,\n              code: BULK_REQUEST_FAILED,\n            })),\n          );\n        }\n        onError?.(error);\n      } finally {\n        setRunning(false);\n        onCompleted?.();\n      }\n    },\n    [run, onCompleted, onError],\n  );\n\n  const [lastKey, setLastKey] = useState<string | undefined>(undefined);\n\n  const onBulkUseCase = useCallback(\n    (key: string, target: EntitySelection<TEntity>) => {\n      setLastKey(key);\n      void execute(key, target);\n    },\n    [execute],\n  );\n\n  const onBulkRetry = useCallback(\n    (ids: EntityId[]) => {\n      if (lastKey === undefined) return;\n      void execute(lastKey, { mode: 'ids', ids: new Set(ids) });\n    },\n    [execute, lastKey],\n  );\n\n  if (!run) return { tableProps: {} };\n\n  return {\n    tableProps: {\n      selection,\n      onSelectionChange: setSelection,\n      onBulkUseCase,\n      bulkOutcomes: outcomes,\n      onBulkDismiss: () => setOutcomes(undefined),\n      onBulkRetry,\n      isBulkRunning: isRunning,\n    },\n  };\n}\n"],"names":["emptySelection","useCallback","useState","BULK_REQUEST_FAILED","useEntityBulk","run","onCompleted","onError","selection","setSelection","outcomes","setOutcomes","undefined","isRunning","setRunning","execute","key","target","error","mode","Array","from","ids","map","id","ok","code","lastKey","setLastKey","onBulkUseCase","onBulkRetry","Set","tableProps","onSelectionChange","bulkOutcomes","onBulkDismiss","isBulkRunning"],"mappings":"AAAA;AAEA,SAEEA,cAAc,QAIT,gBAAgB;AACvB,SAASC,WAAW,EAAEC,QAAQ,QAAQ,QAAQ;AAE9C;;;;;CAKC,GACD,MAAMC,sBAAsB;AA4B5B;;;;;;;;;;;;;;;;CAgBC,GACD,OAAO,SAASC,cAAsC,EACpDC,GAAG,EACHC,WAAW,EACXC,OAAO,EACuB;IAG9B,MAAM,CAACC,WAAWC,aAAa,GAAGP,SAAmC,IACnEF;IAEF,MAAM,CAACU,UAAUC,YAAY,GAAGT,SAC9BU;IAEF,MAAM,CAACC,WAAWC,WAAW,GAAGZ,SAAS;IAEzC,MAAMa,UAAUd,YACd,OAAOe,KAAaC;QAClB,mEAAmE;QACnE,uEAAuE;QACvE,gEAAgE;QAChE,kBAAkB,GAClB,IAAI,CAACZ,KAAK;QACVS,WAAW;QACX,sEAAsE;QACtE,qEAAqE;QACrE,yBAAyB;QACzBH,YAAYC;QACZ,IAAI;YACFD,YAAY,MAAMN,IAAIW,KAAKC;QAC7B,EAAE,OAAOC,OAAO;YACd,wEAAwE;YACxE,wEAAwE;YACxE,iEAAiE;YACjE,sEAAsE;YACtE,kBAAkB;YAClB,EAAE;YACF,uEAAuE;YACvE,gEAAgE;YAChE,wEAAwE;YACxE,qEAAqE;YACrE,yDAAyD;YACzD,IAAID,OAAOE,IAAI,KAAK,OAAO;gBACzBR,YACE,kEAAkE;gBAClE,oDAAoD;gBACpDS,MAAMC,IAAI,CAACJ,OAAOK,GAAG,EAAEC,GAAG,CAACC,CAAAA,KAAO,CAAA;wBAChCA;wBACAC,IAAI;wBACJC,MAAMvB;oBACR,CAAA;YAEJ;YACAI,2BAAAA,QAAUW;QACZ,SAAU;YACRJ,WAAW;YACXR,+BAAAA;QACF;IACF,GACA;QAACD;QAAKC;QAAaC;KAAQ;IAG7B,MAAM,CAACoB,SAASC,WAAW,GAAG1B,SAA6BU;IAE3D,MAAMiB,gBAAgB5B,YACpB,CAACe,KAAaC;QACZW,WAAWZ;QACX,KAAKD,QAAQC,KAAKC;IACpB,GACA;QAACF;KAAQ;IAGX,MAAMe,cAAc7B,YAClB,CAACqB;QACC,IAAIK,YAAYf,WAAW;QAC3B,KAAKG,QAAQY,SAAS;YAAER,MAAM;YAAOG,KAAK,IAAIS,IAAIT;QAAK;IACzD,GACA;QAACP;QAASY;KAAQ;IAGpB,IAAI,CAACtB,KAAK,OAAO;QAAE2B,YAAY,CAAC;IAAE;IAElC,OAAO;QACLA,YAAY;YACVxB;YACAyB,mBAAmBxB;YACnBoB;YACAK,cAAcxB;YACdyB,eAAe,IAAMxB,YAAYC;YACjCkB;YACAM,eAAevB;QACjB;IACF;AACF"}

package/dist/lib/crud/use-entity-link-sources.d.ts

@@ -0,0 +1,25 @@
+import { type Entity, type EntityDraft, type EntityLinkSelection, type EntityLinkSource } from '@entifix/core';
+import type { EntityCrudLinkSource } from './make-entity-crud.types.js';
+export interface UseEntityLinkSourcesOptions {
+    /** The form's current draft — ids are the truth. */
+    readonly values: EntityDraft;
+    /** The picked-instance sidecar, so a chosen name needs no round trip. */
+    readonly selection: EntityLinkSelection;
+}
+/**
+ * Turns a fixed list of pickers into the `linkSources` map `EntityForm` takes.
+ *
+ * **Why the rule is disabled below.** `links` is built once, at factory time,
+ * and closed over by the generated form — it is the same array object on every
+ * render of a given component, so the hook count is fixed. That is exactly the
+ * invariant `react-hooks/rules-of-hooks` exists to protect and exactly the one
+ * it cannot see, because it reasons syntactically about the loop rather than
+ * about the array's provenance. The loop is isolated in this module so the
+ * disable is written once, with its reason, instead of once per generated form.
+ *
+ * The alternative — one child component per picker, reporting its source
+ * upward — would put the sources one render behind the draft that feeds them,
+ * which is a stale suggestion list rather than a lint error.
+ */
+export declare function useEntityLinkSources(links: readonly EntityCrudLinkSource[], { values, selection }: UseEntityLinkSourcesOptions): Record<string, EntityLinkSource<Entity>>;
+//# sourceMappingURL=use-entity-link-sources.d.ts.map

package/dist/lib/crud/use-entity-link-sources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-entity-link-sources.d.ts","sourceRoot":"","sources":["../../../src/lib/crud/use-entity-link-sources.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,MAAM,EACX,KAAK,WAAW,EAChB,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,EAEtB,MAAM,eAAe,CAAC;AAGvB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAExE,MAAM,WAAW,2BAA2B;IAC1C,oDAAoD;IACpD,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,yEAAyE;IACzE,QAAQ,CAAC,SAAS,EAAE,mBAAmB,CAAC;CACzC;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,SAAS,oBAAoB,EAAE,EACtC,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE,2BAA2B,GACjD,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAC,CAiB1C"}

package/dist/lib/crud/use-entity-link-sources.js

@@ -0,0 +1,37 @@
+'use client';
+import { readDraftString } from '@entifix/core';
+import { useEntityLinkSource } from '@entifix/react-integration';
+/**
+ * Turns a fixed list of pickers into the `linkSources` map `EntityForm` takes.
+ *
+ * **Why the rule is disabled below.** `links` is built once, at factory time,
+ * and closed over by the generated form — it is the same array object on every
+ * render of a given component, so the hook count is fixed. That is exactly the
+ * invariant `react-hooks/rules-of-hooks` exists to protect and exactly the one
+ * it cannot see, because it reasons syntactically about the loop rather than
+ * about the array's provenance. The loop is isolated in this module so the
+ * disable is written once, with its reason, instead of once per generated form.
+ *
+ * The alternative — one child component per picker, reporting its source
+ * upward — would put the sources one render behind the draft that feeds them,
+ * which is a stale suggestion list rather than a lint error.
+ */ export function useEntityLinkSources(links, { values, selection }) {
+    const sources = {};
+    for (const link of links){
+        // Read as a string: a relation's draft value is a foreign key, and a
+        // member that came back from storage in any other shape must read as unset
+        // rather than be handed to the picker as an id.
+        const held = readDraftString(values, link.field);
+        // eslint-disable-next-line react-hooks/rules-of-hooks -- fixed-length loop over a factory-time array; see the note above.
+        sources[link.field] = useEntityLinkSource(link.config, {
+            descriptor: link.descriptor,
+            // An empty draft entry is "unset", not an id. Nothing enforces the
+            // reference across a store boundary, so `''` would be a dangling id.
+            selectedId: held === '' ? undefined : held,
+            selectedEntity: selection[link.field]
+        });
+    }
+    return sources;
+}
+
+//# sourceMappingURL=use-entity-link-sources.js.map

package/dist/lib/crud/use-entity-link-sources.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/crud/use-entity-link-sources.ts"],"sourcesContent":["'use client';\n\nimport {\n  type Entity,\n  type EntityDraft,\n  type EntityLinkSelection,\n  type EntityLinkSource,\n  readDraftString,\n} from '@entifix/core';\nimport { useEntityLinkSource } from '@entifix/react-integration';\n\nimport type { EntityCrudLinkSource } from './make-entity-crud.types.js';\n\nexport interface UseEntityLinkSourcesOptions {\n  /** The form's current draft — ids are the truth. */\n  readonly values: EntityDraft;\n  /** The picked-instance sidecar, so a chosen name needs no round trip. */\n  readonly selection: EntityLinkSelection;\n}\n\n/**\n * Turns a fixed list of pickers into the `linkSources` map `EntityForm` takes.\n *\n * **Why the rule is disabled below.** `links` is built once, at factory time,\n * and closed over by the generated form — it is the same array object on every\n * render of a given component, so the hook count is fixed. That is exactly the\n * invariant `react-hooks/rules-of-hooks` exists to protect and exactly the one\n * it cannot see, because it reasons syntactically about the loop rather than\n * about the array's provenance. The loop is isolated in this module so the\n * disable is written once, with its reason, instead of once per generated form.\n *\n * The alternative — one child component per picker, reporting its source\n * upward — would put the sources one render behind the draft that feeds them,\n * which is a stale suggestion list rather than a lint error.\n */\nexport function useEntityLinkSources(\n  links: readonly EntityCrudLinkSource[],\n  { values, selection }: UseEntityLinkSourcesOptions,\n): Record<string, EntityLinkSource<Entity>> {\n  const sources: Record<string, EntityLinkSource<Entity>> = {};\n  for (const link of links) {\n    // Read as a string: a relation's draft value is a foreign key, and a\n    // member that came back from storage in any other shape must read as unset\n    // rather than be handed to the picker as an id.\n    const held = readDraftString(values, link.field);\n    // eslint-disable-next-line react-hooks/rules-of-hooks -- fixed-length loop over a factory-time array; see the note above.\n    sources[link.field] = useEntityLinkSource(link.config, {\n      descriptor: link.descriptor,\n      // An empty draft entry is \"unset\", not an id. Nothing enforces the\n      // reference across a store boundary, so `''` would be a dangling id.\n      selectedId: held === '' ? undefined : held,\n      selectedEntity: selection[link.field],\n    });\n  }\n  return sources;\n}\n"],"names":["readDraftString","useEntityLinkSource","useEntityLinkSources","links","values","selection","sources","link","held","field","config","descriptor","selectedId","undefined","selectedEntity"],"mappings":"AAAA;AAEA,SAKEA,eAAe,QACV,gBAAgB;AACvB,SAASC,mBAAmB,QAAQ,6BAA6B;AAWjE;;;;;;;;;;;;;;CAcC,GACD,OAAO,SAASC,qBACdC,KAAsC,EACtC,EAAEC,MAAM,EAAEC,SAAS,EAA+B;IAElD,MAAMC,UAAoD,CAAC;IAC3D,KAAK,MAAMC,QAAQJ,MAAO;QACxB,qEAAqE;QACrE,2EAA2E;QAC3E,gDAAgD;QAChD,MAAMK,OAAOR,gBAAgBI,QAAQG,KAAKE,KAAK;QAC/C,0HAA0H;QAC1HH,OAAO,CAACC,KAAKE,KAAK,CAAC,GAAGR,oBAAoBM,KAAKG,MAAM,EAAE;YACrDC,YAAYJ,KAAKI,UAAU;YAC3B,mEAAmE;YACnE,qEAAqE;YACrEC,YAAYJ,SAAS,KAAKK,YAAYL;YACtCM,gBAAgBT,SAAS,CAACE,KAAKE,KAAK,CAAC;QACvC;IACF;IACA,OAAOH;AACT"}

package/dist/lib/health/health-routes.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Probe route handlers for the Next apps, mirroring what
+ * `@entifix/service-shell` mounts on the backends.
+ *
+ * They ship from `@entifix/next-shell/server` because a route handler must
+ * not come from the `"use client"` bundle.
+ */
+export interface HealthRouteOptions {
+    /** The app's package name, echoed back so a probe says what it reached. */
+    readonly app: string;
+    /** Base URL of config-service, e.g. `http://localhost:3190`. */
+    readonly configApiUrl: string;
+    /** The app's config key, i.e. the `:service` in `GET /api/config/:service`. */
+    readonly configKey: string;
+}
+/**
+ * Build the `GET` handlers for `/api/health`, `/api/health/live` and
+ * `/api/health/ready`.
+ *
+ * **Liveness** answers from the process alone — no config-service, no backend,
+ * no session. That is what makes it usable as Playwright's `readyPath` and what
+ * keeps a dependency blip from getting the app killed by Kubernetes later.
+ *
+ * **Readiness** checks the one dependency the app cannot render without: its
+ * configuration. It deliberately does *not* chain to the domain backend —
+ * cascading readiness turns one degraded service into a fleet-wide outage, and
+ * a page that renders with a degraded backend is still worth serving.
+ */
+export declare const createHealthRoutes: (options: HealthRouteOptions) => {
+    /** `GET /api/health` — the original endpoint, unchanged. */
+    health: () => Response;
+    /** `GET /api/health/live` */
+    live: () => Response;
+    /** `GET /api/health/ready` */
+    ready: () => Promise<Response>;
+};
+//# sourceMappingURL=health-routes.d.ts.map

package/dist/lib/health/health-routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"health-routes.d.ts","sourceRoot":"","sources":["../../../src/lib/health/health-routes.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAiCH,MAAM,WAAW,kBAAkB;IACjC,2EAA2E;IAC3E,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,gEAAgE;IAChE,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,+EAA+E;IAC/E,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,kBAAkB,GAAI,SAAS,kBAAkB;IAuB1D,4DAA4D;;IAG5D,6BAA6B;;IAQ7B,8BAA8B;;CAejC,CAAC"}

package/dist/lib/health/health-routes.js

@@ -0,0 +1,90 @@
+/**
+ * Probe route handlers for the Next apps, mirroring what
+ * `@entifix/service-shell` mounts on the backends.
+ *
+ * They ship from `@entifix/next-shell/server` because a route handler must
+ * not come from the `"use client"` bundle.
+ */ import { SERVICE_TOKEN_HEADER, serviceToken } from '../config/service-token.js';
+/** How long a readiness result is reused, so probes cannot hammer config-service. */ const READY_CACHE_MS = 1000;
+/** A readiness check that hangs is a readiness check that failed. */ const READY_TIMEOUT_MS = 2000;
+/**
+ * Which build is answering: `next dev` or `next start`.
+ *
+ * Liveness carries it because an e2e run needs to know *which artifact* it
+ * attached to. Playwright reuses whatever already listens on the app's port, so
+ * a suite started while a dev server is up tests a different bundle against a
+ * different backend than the one it claims to — see `assertExpectedServer` in
+ * `@entifix/testing-e2e/playwright`.
+ *
+ * On liveness rather than readiness because liveness is the one endpoint that
+ * answers from the process alone, before config-service or any backend is up.
+ *
+ * Not an information leak worth avoiding: a dev build already announces itself
+ * in its asset paths long before anything asks this endpoint.
+ */ const buildMode = ()=>process.env.NODE_ENV === 'production' ? 'production' : 'development';
+/**
+ * Build the `GET` handlers for `/api/health`, `/api/health/live` and
+ * `/api/health/ready`.
+ *
+ * **Liveness** answers from the process alone — no config-service, no backend,
+ * no session. That is what makes it usable as Playwright's `readyPath` and what
+ * keeps a dependency blip from getting the app killed by Kubernetes later.
+ *
+ * **Readiness** checks the one dependency the app cannot render without: its
+ * configuration. It deliberately does *not* chain to the domain backend —
+ * cascading readiness turns one degraded service into a fleet-wide outage, and
+ * a page that renders with a degraded backend is still worth serving.
+ */ export const createHealthRoutes = (options)=>{
+    let cached = null;
+    const checkConfig = async ()=>{
+        try {
+            // The fleet token is not optional here: `GET /api/config/:service` serves
+            // real credentials and answers `401` without it, which a readiness probe
+            // reads as "degraded" — permanently, for an app that is in fact fine.
+            const response = await fetch(`${options.configApiUrl}/api/config/${options.configKey}`, {
+                signal: AbortSignal.timeout(READY_TIMEOUT_MS),
+                cache: 'no-store',
+                headers: {
+                    [SERVICE_TOKEN_HEADER]: serviceToken()
+                }
+            });
+            return response.ok;
+        } catch (unused) {
+            return false;
+        }
+    };
+    return {
+        /** `GET /api/health` — the original endpoint, unchanged. */ health: ()=>Response.json({
+                status: 'ok',
+                app: options.app
+            }),
+        /** `GET /api/health/live` */ live: ()=>Response.json({
+                status: 'live',
+                app: options.app,
+                mode: buildMode()
+            }),
+        /** `GET /api/health/ready` */ ready: async ()=>{
+            const now = Date.now();
+            if (cached === null || now - cached.at >= READY_CACHE_MS) {
+                cached = {
+                    at: now,
+                    ready: await checkConfig()
+                };
+            }
+            return cached.ready ? Response.json({
+                status: 'ready',
+                app: options.app
+            }) : Response.json({
+                status: 'degraded',
+                app: options.app,
+                failing: [
+                    'config'
+                ]
+            }, {
+                status: 503
+            });
+        }
+    };
+};
+
+//# sourceMappingURL=health-routes.js.map

package/dist/lib/health/health-routes.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/health/health-routes.ts"],"sourcesContent":["/**\n * Probe route handlers for the Next apps, mirroring what\n * `@entifix/service-shell` mounts on the backends.\n *\n * They ship from `@entifix/next-shell/server` because a route handler must\n * not come from the `\"use client\"` bundle.\n */\n\nimport { SERVICE_TOKEN_HEADER, serviceToken } from '../config/service-token.js';\n\n/** How long a readiness result is reused, so probes cannot hammer config-service. */\nconst READY_CACHE_MS = 1_000;\n\n/** A readiness check that hangs is a readiness check that failed. */\nconst READY_TIMEOUT_MS = 2_000;\n\n/**\n * Which build is answering: `next dev` or `next start`.\n *\n * Liveness carries it because an e2e run needs to know *which artifact* it\n * attached to. Playwright reuses whatever already listens on the app's port, so\n * a suite started while a dev server is up tests a different bundle against a\n * different backend than the one it claims to — see `assertExpectedServer` in\n * `@entifix/testing-e2e/playwright`.\n *\n * On liveness rather than readiness because liveness is the one endpoint that\n * answers from the process alone, before config-service or any backend is up.\n *\n * Not an information leak worth avoiding: a dev build already announces itself\n * in its asset paths long before anything asks this endpoint.\n */\nconst buildMode = (): 'development' | 'production' =>\n  process.env.NODE_ENV === 'production' ? 'production' : 'development';\n\ninterface ReadyState {\n  readonly at: number;\n  readonly ready: boolean;\n}\n\nexport interface HealthRouteOptions {\n  /** The app's package name, echoed back so a probe says what it reached. */\n  readonly app: string;\n  /** Base URL of config-service, e.g. `http://localhost:3190`. */\n  readonly configApiUrl: string;\n  /** The app's config key, i.e. the `:service` in `GET /api/config/:service`. */\n  readonly configKey: string;\n}\n\n/**\n * Build the `GET` handlers for `/api/health`, `/api/health/live` and\n * `/api/health/ready`.\n *\n * **Liveness** answers from the process alone — no config-service, no backend,\n * no session. That is what makes it usable as Playwright's `readyPath` and what\n * keeps a dependency blip from getting the app killed by Kubernetes later.\n *\n * **Readiness** checks the one dependency the app cannot render without: its\n * configuration. It deliberately does *not* chain to the domain backend —\n * cascading readiness turns one degraded service into a fleet-wide outage, and\n * a page that renders with a degraded backend is still worth serving.\n */\nexport const createHealthRoutes = (options: HealthRouteOptions) => {\n  let cached: ReadyState | null = null;\n\n  const checkConfig = async (): Promise<boolean> => {\n    try {\n      // The fleet token is not optional here: `GET /api/config/:service` serves\n      // real credentials and answers `401` without it, which a readiness probe\n      // reads as \"degraded\" — permanently, for an app that is in fact fine.\n      const response = await fetch(\n        `${options.configApiUrl}/api/config/${options.configKey}`,\n        {\n          signal: AbortSignal.timeout(READY_TIMEOUT_MS),\n          cache: 'no-store',\n          headers: { [SERVICE_TOKEN_HEADER]: serviceToken() },\n        },\n      );\n      return response.ok;\n    } catch {\n      return false;\n    }\n  };\n\n  return {\n    /** `GET /api/health` — the original endpoint, unchanged. */\n    health: () => Response.json({ status: 'ok', app: options.app }),\n\n    /** `GET /api/health/live` */\n    live: () =>\n      Response.json({\n        status: 'live',\n        app: options.app,\n        mode: buildMode(),\n      }),\n\n    /** `GET /api/health/ready` */\n    ready: async () => {\n      const now = Date.now();\n      if (cached === null || now - cached.at >= READY_CACHE_MS) {\n        cached = { at: now, ready: await checkConfig() };\n      }\n\n      return cached.ready\n        ? Response.json({ status: 'ready', app: options.app })\n        : Response.json(\n            { status: 'degraded', app: options.app, failing: ['config'] },\n            { status: 503 },\n          );\n    },\n  };\n};\n"],"names":["SERVICE_TOKEN_HEADER","serviceToken","READY_CACHE_MS","READY_TIMEOUT_MS","buildMode","process","env","NODE_ENV","createHealthRoutes","options","cached","checkConfig","response","fetch","configApiUrl","configKey","signal","AbortSignal","timeout","cache","headers","ok","health","Response","json","status","app","live","mode","ready","now","Date","at","failing"],"mappings":"AAAA;;;;;;CAMC,GAED,SAASA,oBAAoB,EAAEC,YAAY,QAAQ,6BAA6B;AAEhF,mFAAmF,GACnF,MAAMC,iBAAiB;AAEvB,mEAAmE,GACnE,MAAMC,mBAAmB;AAEzB;;;;;;;;;;;;;;CAcC,GACD,MAAMC,YAAY,IAChBC,QAAQC,GAAG,CAACC,QAAQ,KAAK,eAAe,eAAe;AAgBzD;;;;;;;;;;;;CAYC,GACD,OAAO,MAAMC,qBAAqB,CAACC;IACjC,IAAIC,SAA4B;IAEhC,MAAMC,cAAc;QAClB,IAAI;YACF,0EAA0E;YAC1E,yEAAyE;YACzE,sEAAsE;YACtE,MAAMC,WAAW,MAAMC,MACrB,GAAGJ,QAAQK,YAAY,CAAC,YAAY,EAAEL,QAAQM,SAAS,EAAE,EACzD;gBACEC,QAAQC,YAAYC,OAAO,CAACf;gBAC5BgB,OAAO;gBACPC,SAAS;oBAAE,CAACpB,qBAAqB,EAAEC;gBAAe;YACpD;YAEF,OAAOW,SAASS,EAAE;QACpB,EAAE,eAAM;YACN,OAAO;QACT;IACF;IAEA,OAAO;QACL,0DAA0D,GAC1DC,QAAQ,IAAMC,SAASC,IAAI,CAAC;gBAAEC,QAAQ;gBAAMC,KAAKjB,QAAQiB,GAAG;YAAC;QAE7D,2BAA2B,GAC3BC,MAAM,IACJJ,SAASC,IAAI,CAAC;gBACZC,QAAQ;gBACRC,KAAKjB,QAAQiB,GAAG;gBAChBE,MAAMxB;YACR;QAEF,4BAA4B,GAC5ByB,OAAO;YACL,MAAMC,MAAMC,KAAKD,GAAG;YACpB,IAAIpB,WAAW,QAAQoB,MAAMpB,OAAOsB,EAAE,IAAI9B,gBAAgB;gBACxDQ,SAAS;oBAAEsB,IAAIF;oBAAKD,OAAO,MAAMlB;gBAAc;YACjD;YAEA,OAAOD,OAAOmB,KAAK,GACfN,SAASC,IAAI,CAAC;gBAAEC,QAAQ;gBAASC,KAAKjB,QAAQiB,GAAG;YAAC,KAClDH,SAASC,IAAI,CACX;gBAAEC,QAAQ;gBAAYC,KAAKjB,QAAQiB,GAAG;gBAAEO,SAAS;oBAAC;iBAAS;YAAC,GAC5D;gBAAER,QAAQ;YAAI;QAEtB;IACF;AACF,EAAE"}

package/dist/lib/i18n/catalog/en.d.ts

@@ -0,0 +1,4 @@
+type EsShell = typeof import('./es.js').shell;
+export declare const shell: EsShell;
+export {};
+//# sourceMappingURL=en.d.ts.map

package/dist/lib/i18n/catalog/en.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"en.d.ts","sourceRoot":"","sources":["../../../../src/lib/i18n/catalog/en.ts"],"names":[],"mappings":"AAAA,KAAK,OAAO,GAAG,cAAc,SAAS,EAAE,KAAK,CAAC;AAE9C,eAAO,MAAM,KAAK,EAAE,OAsWnB,CAAC"}