@rdlabo/workers-hono-kit 0.9.3 → 0.9.5

package/README.md

@@ -210,7 +210,8 @@ client-generated UUID in `local_id` and keep `server_id` null until the server c
 | Export | Description |
 | --- | --- |
 | `defineRestDbMethodConverter(converter)` | Type a product-owned, pure `MethodScheme ↔ TableScheme` converter without hiding HTTP or persistence side effects. |
-| `RestDbMethodConverter` | Product-owned converter contract. Its table scheme requires every represented table and column, including optional nullable/default keys from `$inferInsert`. |
+| `RestDbMethodConverter` | Product-owned converter contract. Select and insert bundles may differ; every represented table and column remains required. |
+| `CompleteRestDbTableScheme` | Compile-time lock requiring every represented table key and row column. |
 | `toReplicaIsoDatetime(value)` | `Date` / datetime string → canonical UTC ISO-8601 wire value. |
 | `toReplicaDateOnly(value)` | `Date` / date string / `null` → canonical `YYYY-MM-DD` / `null`. |
 | `replicaTimestampMs(value)` | Replica datetime → epoch milliseconds for legacy DTOs. |
@@ -255,6 +256,20 @@ type CreateTables = {
 The converter then cannot demand or manufacture `id`; the server adds the generated id to the
 confirmed response before it is stored as `server_id`.
 
+When a write needs authenticated ownership or scope that is intentionally absent from the public
+REST body, use separate select/insert bundles and an explicit write context. The original
+two-generic form remains valid.
+
+```ts
+defineRestDbMethodConverter<Method, SelectTables, InsertTables, { userId: number }>({
+  toMethodScheme: ({ foods, allergens }) => composeFood(foods, allergens),
+  toTableScheme: (method, { userId }) => ({
+    foods: [{ userId, name: method.name, memo: method.memo ?? null }],
+    allergens: method.allergens.map((value) => ({ value })),
+  }),
+});
+```
+
 ```ts
 replicaNowIso(() => new Date('2026-07-23T10:00:00Z')); // '2026-07-23T10:00:00.000Z'
 toReplicaIsoDatetime('2026-07-23T19:00:00+09:00'); // '2026-07-23T10:00:00.000Z'

package/dist/middleware/perf-log.d.ts

@@ -31,6 +31,8 @@ export interface PerfLogOptions {
      * When provided, write one data point per request to a **Workers Analytics Engine** dataset. Query
      * percentiles by route/colo with the SQL API (≈90-day retention). Non-blocking. Layout:
      * `doubles = [t_app_ms, cold(0|1), status]`, `blobs = [path, colo, method]`, `indexes = [path]`.
+     * Route patterns longer than Analytics Engine's 96-byte index limit use a stable hash as the index;
+     * the complete route remains available in `blob1`.
      */
     dataset?: AnalyticsEngineDatasetLike;
     /**

package/dist/middleware/perf-log.js

@@ -18,6 +18,20 @@
 // a cold start are labelled warm (only the very first flips the flag) even though they pay cold-init
 // waits — a minor warm-side contamination, negligible at the low request rates this targets.
 let isolateWarm = false;
+const ANALYTICS_INDEX_MAX_BYTES = 96;
+function analyticsIndex(path) {
+    const bytes = new TextEncoder().encode(path);
+    if (bytes.byteLength <= ANALYTICS_INDEX_MAX_BYTES) {
+        return path;
+    }
+    // FNV-1a 64-bit keeps sampling deterministic without adding async crypto work to every response.
+    let hash = 0xcbf29ce484222325n;
+    for (const byte of bytes) {
+        hash ^= BigInt(byte);
+        hash = BigInt.asUintN(64, hash * 0x100000001b3n);
+    }
+    return `route:${hash.toString(16).padStart(16, '0')}`;
+}
 /**
  * Create a Hono middleware that records a per-request latency data point and emits it to Workers
  * Logs (`console`) and/or Workers Analytics Engine (`dataset`).
@@ -84,11 +98,17 @@ export function perfLog(options = {}) {
         // In-code sampling thins Analytics Engine writes only; Workers Logs volume is controlled separately
         // by the observability `head_sampling_rate`. Low-traffic Workers should leave `sampleRate` at 1.
         if (sink && (rate >= 1 || Math.random() < rate)) {
-            sink.writeDataPoint({
-                doubles: [tApp, cold ? 1 : 0, status],
-                blobs: [path, colo, method],
-                indexes: [path],
-            });
+            try {
+                sink.writeDataPoint({
+                    doubles: [tApp, cold ? 1 : 0, status],
+                    blobs: [path, colo, method],
+                    indexes: [analyticsIndex(path)],
+                });
+            }
+            catch (error) {
+                // Telemetry must never replace an otherwise successful application response with a 500.
+                console.warn('[perfLog] Analytics Engine write failed', error);
+            }
         }
         if (emitConsole) {
             console.log(JSON.stringify({ perf: { cold, colo, method, path, status, t_app: tApp } }));

package/dist/offline/index.d.ts

@@ -9,6 +9,6 @@
 export { fromTinyIntFlag, replicaTimestampMs, toReplicaDateOnly, toReplicaIsoDatetime, toTinyIntFlag } from './wire.js';
 export { replicaNowIso } from './clock.js';
 export { defineRestDbMethodConverter } from './rest-db-method-converter.js';
-export type { RestDbMethodConverter } from './rest-db-method-converter.js';
+export type { CompleteRestDbTableScheme, RestDbMethodConverter } from './rest-db-method-converter.js';
 export { decodeOfflineSnapshotCursor, encodeOfflineSnapshotCursor } from './snapshot-cursor.js';
 export type { OfflineSnapshotCursor } from './snapshot-cursor.js';

package/dist/offline/rest-db-method-converter.d.ts

@@ -17,7 +17,7 @@ type CompleteDbTableValue<TValue> = TValue extends (infer TRow)[] ? TRow extends
  * intentionally does not own a generated column must exclude it from its
  * product-owned scheme first, for example `Omit<InsertRow, 'id'>`.
  */
-type CompleteRestDbTableScheme<TTableScheme extends object> = {
+export type CompleteRestDbTableScheme<TTableScheme extends object> = {
     [TTableName in keyof TTableScheme]-?: CompleteDbTableValue<TTableScheme[TTableName]>;
 };
 /**
@@ -28,9 +28,9 @@ type CompleteRestDbTableScheme<TTableScheme extends object> = {
  * `$inferInsert` type marks them optional. Nullability does not make a column
  * optional in the conversion contract.
  */
-export interface RestDbMethodConverter<TMethodScheme, TTableScheme extends object> {
-    toMethodScheme(tableScheme: Readonly<CompleteRestDbTableScheme<TTableScheme>>): TMethodScheme;
-    toTableScheme(methodScheme: Readonly<TMethodScheme>): CompleteRestDbTableScheme<TTableScheme>;
+export interface RestDbMethodConverter<TMethodScheme, TSelectTableScheme extends object, TInsertTableScheme extends object = TSelectTableScheme, TWriteContext = never> {
+    toMethodScheme(tableScheme: Readonly<CompleteRestDbTableScheme<TSelectTableScheme>>): TMethodScheme;
+    toTableScheme(methodScheme: Readonly<TMethodScheme>, ...context: [TWriteContext] extends [never] ? [] : [context: Readonly<TWriteContext>]): CompleteRestDbTableScheme<TInsertTableScheme>;
 }
 /**
  * Define a product-specific REST ↔ DB converter with contextual return types.
@@ -38,5 +38,5 @@ export interface RestDbMethodConverter<TMethodScheme, TTableScheme extends objec
  * This is intentionally an identity function: conversion remains explicit,
  * synchronous, and free of hidden persistence or HTTP side effects.
  */
-export declare function defineRestDbMethodConverter<TMethodScheme, TTableScheme extends object>(converter: RestDbMethodConverter<TMethodScheme, TTableScheme>): RestDbMethodConverter<TMethodScheme, TTableScheme>;
+export declare function defineRestDbMethodConverter<TMethodScheme, TSelectTableScheme extends object, TInsertTableScheme extends object = TSelectTableScheme, TWriteContext = never>(converter: RestDbMethodConverter<TMethodScheme, TSelectTableScheme, TInsertTableScheme, TWriteContext>): RestDbMethodConverter<TMethodScheme, TSelectTableScheme, TInsertTableScheme, TWriteContext>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rdlabo/workers-hono-kit",
-  "version": "0.9.3",
+  "version": "0.9.5",
   "private": false,
   "publishConfig": {
     "access": "public"