@12-apps/storage 2.5.0 → 2.6.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@12-apps/storage",
-  "version": "2.5.0",
+  "version": "2.6.1",
   "type": "module",
   "description": "Image uploads that land at YOUR OWN ORIGIN, never at the bucket (12-20). Isomorphic core (format allowlist, upload ceiling, object-key grammar, rendition set, refusal taxonomy, wire schemas), host-mounted backend surface (./server: createApiStorage, the local-disk driver, the image-pipeline port, the orphan reclaim), Hono adapter (./hono), the S3-compatible driver behind its own subpath (./s3) and the bound picker + upload hook (./react). Standardized adoption contract in ADOPTING.md.",
   "exports": {
@@ -48,9 +48,9 @@
   },
   "devDependencies": {
     "@12-apps/eslint-config": "^1.21.1",
-    "@12-apps/i18n": "^1.0.0",
+    "@12-apps/i18n": "^1.1.0",
     "@12-apps/typescript-config": "^1.20.1",
-    "@12-apps/wiring": "^1.10.0",
+    "@12-apps/wiring": "^1.12.1",
     "@aws-sdk/client-s3": "^3.703.0",
     "@testing-library/react": "^16.1.0",
     "@types/react": "19.2.2",

package/src/manifest/server.ts

@@ -57,11 +57,20 @@ function asWireRoute(route: StorageRoute): {
   method: StorageRoute['method'];
   path: string;
   kind: 'authenticated' | 'public';
+  wildcardParam?: string;
   handle(request: WireRequest): Promise<WireRouteAnswer>;
 } {
   return {
     method: route.method,
     path: route.path,
+    // Forwarded, and it has to be: the serve route's key is FOUR segments
+    // (`products/<scope>/<uuid>/card-320.webp`), so an adapter that registers
+    // only `path` answers the prefix and 404s every real object. `./hono`
+    // spells the Hono form from this name; the contract carries the name so any
+    // other adapter can spell its own. Dropping it here is what made this
+    // package unmountable through a consumer at all — silently, because the
+    // upload route worked and only reads 404'd.
+    ...(route.wildcardParam === undefined ? {} : { wildcardParam: route.wildcardParam }),
     // The descriptor's own `auth` flag IS the contract's route kind: a
     // `public` object read is anonymous by design, and the host's gates read
     // this rather than a second table that could disagree with it.

package/src/problems.ts

@@ -54,6 +54,15 @@ export type StorageMessages = Readonly<Record<StorageProblem, string>>;
 export interface StorageMessageContext {
   /** `8 MB`, already formatted. */
   limit: string;
+  /**
+   * The language to answer this caller in, as a BCP-47 tag.
+   *
+   * This field is why `messages` was already the right SHAPE: a factory called
+   * per refusal can answer per reader, where a value handed over at the mount
+   * cannot. Absent means the host's adapter populated nothing — a single
+   * -audience host — and the factory should then answer as it always did.
+   */
+  locale?: string;
 }
 
 /**

package/src/server/create-api-storage.ts

@@ -172,11 +172,14 @@ const SILENT: StorageLogger = { error: () => undefined };
 export function createApiStorage(config: ApiStorageConfig): ApiStorage {
   const specs = config.renditions ?? CATALOG_RENDITIONS;
   const keyPrefix = config.keyPrefix ?? DEFAULT_KEY_PREFIX;
-  const messages: StorageMessages = config.messages({ limit: megabytes(config.maxBytes) });
+  const limit = megabytes(config.maxBytes);
+  // A host write holds no request and no reader, so it takes the words resolved
+  // in the deployment's own language. The ROUTES resolve per caller instead —
+  // see `storageRoutes` below, which is handed the factory rather than this.
   const writeDeps: StoreImageDeps = {
     driver: config.driver,
     pipeline: config.imagePipeline,
-    messages,
+    messages: config.messages({ limit }),
     maxBytes: config.maxBytes,
     specs,
     keyPrefix,
@@ -192,7 +195,7 @@ export function createApiStorage(config: ApiStorageConfig): ApiStorage {
   const resolve = (key: string): string => config.driver.publicUrl(key);
 
   return {
-    routes: storageRoutes(writeDeps),
+    routes: storageRoutes({ ...writeDeps, messages: config.messages, limit }),
     limits: {
       maxBytes: config.maxBytes,
       maxBytesLabel: megabytes(config.maxBytes),

package/src/server/routes.ts

@@ -1,7 +1,7 @@
 import { CONTENT_TYPE_BY_EXTENSION, acceptedContentTypeOf } from '../content-types';
 import { parseObjectMemberKey } from '../keys';
 import { STORAGE_PATHS } from '../paths';
-import { isStorageProblem, type StorageMessages } from '../problems';
+import { isStorageProblem, type StorageMessageContext, type StorageMessages } from '../problems';
 import type { StorageDriver } from './driver';
 import { readBodyCapped } from './read-body';
 import { storeImage, type StoreImageDeps } from './store-image';
@@ -54,6 +54,12 @@ export interface StorageRouteContext {
   actor: StorageActor | null;
   params: Record<string, string | undefined>;
   request: Request;
+  /**
+   * The language to answer in — the same field `@12-apps/wiring`'s
+   * `WireRequest` carries, mirrored here because this surface builds its own
+   * context. Populated by the host's adapter; absent is not an error.
+   */
+  locale?: string;
 }
 
 /** A JSON answer, an object's bytes, or a redirect to where the object lives. */
@@ -76,9 +82,15 @@ export interface StorageRoute {
   handle(context: StorageRouteContext): Promise<StorageRouteResponse>;
 }
 
-interface RoutesDeps extends StoreImageDeps {
+interface RoutesDeps extends Omit<StoreImageDeps, "messages"> {
   driver: StorageDriver;
-  messages: StorageMessages;
+  /**
+   * The factory, unresolved, plus the limit it needs. Resolving into a value
+   * here is what would re-freeze the language into the mount — this object is
+   * built once, per process.
+   */
+  messages: (context: StorageMessageContext) => StorageMessages;
+  limit: string;
 }
 
 /** Keys are content-addressed (a uuid), so an object may be cached forever. */
@@ -96,9 +108,12 @@ async function handleUpload(
     // override it (`WebStorageMessages.forbidden`).
     return { status: 403, body: { error: 'forbidden' } };
   }
+  // Worded HERE, per request, from the tag the adapter put on the context —
+  // never at the mount, which ran once at boot.
+  const messages = deps.messages({ limit: deps.limit, locale: context.locale });
   const contentType = acceptedContentTypeOf(context.request.headers.get('content-type'));
   if (!contentType) {
-    return { status: 400, body: { error: deps.messages.unsupported_content_type } };
+    return { status: 400, body: { error: messages.unsupported_content_type } };
   }
   // Capped WHILE STREAMING, so an oversize body is refused without ever being
   // held whole in memory.
@@ -111,12 +126,12 @@ async function handleUpload(
     // "o limite é 8 MB": a ceiling nothing enforced, in the one package whose
     // headline claim is that there is exactly ONE number. The sentence is built
     // from this mount's `maxBytes` and carries this mount's `messages` overrides.
-    return { status: 413, body: { error: deps.messages.file_too_large } };
+    return { status: 413, body: { error: messages.file_too_large } };
   }
   try {
     // No byte check here: `storeImage` owns it, so the endpoint and a host write
     // holding raw bytes cannot disagree about whether it ran (see store-image.ts).
-    const imageKey = await storeImage(deps, { bytes, contentType, scope: actor.scope });
+    const imageKey = await storeImage({ ...deps, messages }, { bytes, contentType, scope: actor.scope });
     return { status: 200, body: { data: { imageKey } } };
   } catch (error) {
     // The write path speaks in StorageProblemError precisely so both entrances