@holo-js/adapter-shared 0.3.19 → 0.3.20

package/dist/build.d.ts

@@ -1,5 +1,7 @@
 declare function compileBrowserValidation(source: string, fileName?: string): string | undefined;
 
+declare function compileNextRoute(source: string, filename: string): string;
+
 type RealtimeDefinitionSourceMap = {
     readonly version: 3;
     readonly file: string;
@@ -19,4 +21,4 @@ declare function stripRealtimeServerHandlers(source: string): string;
 declare function createRealtimeClientDefinitionModule(source: string, importTarget: string): string;
 declare function createRealtimeClientDefinitionTransform(source: string, importTarget: string, options?: RealtimeDefinitionTransformOptions): RealtimeDefinitionTransformResult;
 
-export { type RealtimeDefinitionSourceMap, type RealtimeDefinitionTransformOptions, type RealtimeDefinitionTransformResult, compileBrowserValidation, createRealtimeClientDefinitionModule, createRealtimeClientDefinitionTransform, stripRealtimeServerHandlers };
+export { type RealtimeDefinitionSourceMap, type RealtimeDefinitionTransformOptions, type RealtimeDefinitionTransformResult, compileBrowserValidation, compileNextRoute, createRealtimeClientDefinitionModule, createRealtimeClientDefinitionTransform, stripRealtimeServerHandlers };

package/dist/build.mjs

@@ -1,11 +1,13 @@
 import {
   compileBrowserValidation,
+  compileNextRoute,
   createRealtimeClientDefinitionModule,
   createRealtimeClientDefinitionTransform,
   stripRealtimeServerHandlers
-} from "./chunk-4DGYQBYZ.mjs";
+} from "./chunk-6FHRFQPC.mjs";
 export {
   compileBrowserValidation,
+  compileNextRoute,
   createRealtimeClientDefinitionModule,
   createRealtimeClientDefinitionTransform,
   stripRealtimeServerHandlers

package/dist/{chunk-4DGYQBYZ.mjs → chunk-6FHRFQPC.mjs}

@@ -1,5 +1,5 @@
 // src/build.ts
-import ts2 from "typescript";
+import ts3 from "typescript";
 
 // src/validation-transform.ts
 import ts from "typescript";
@@ -143,10 +143,107 @@ import * as ${runtime} from '@holo-js/validation/internal/compiled'
 `;
 }
 
+// src/next-route-transform.ts
+import ts2 from "typescript";
+var METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "OPTIONS", "POST", "PUT", "PATCH", "DELETE"]);
+var runtimeName = "__holoRouteRuntime";
+function wrap(handler) {
+  return ts2.factory.createCallExpression(
+    ts2.factory.createPropertyAccessExpression(ts2.factory.createIdentifier(runtimeName), "routeHandler"),
+    void 0,
+    [handler]
+  );
+}
+function exportHandler(name, handler) {
+  return ts2.factory.createVariableStatement(
+    [ts2.factory.createModifier(ts2.SyntaxKind.ExportKeyword)],
+    ts2.factory.createVariableDeclarationList([
+      ts2.factory.createVariableDeclaration(name, void 0, void 0, wrap(handler))
+    ], ts2.NodeFlags.Const)
+  );
+}
+function compileNextRoute(source, filename) {
+  const file = ts2.createSourceFile(filename, source, ts2.ScriptTarget.Latest, true, ts2.ScriptKind.TS);
+  let changed = false;
+  const statements = file.statements.flatMap((statement) => {
+    if (ts2.isFunctionDeclaration(statement) && statement.name && METHODS.has(statement.name.text) && statement.modifiers?.some((modifier) => modifier.kind === ts2.SyntaxKind.ExportKeyword)) {
+      changed = true;
+      const name = statement.name.text;
+      const localName = ts2.factory.createIdentifier(`__holoOriginal${name}`);
+      return [ts2.factory.updateFunctionDeclaration(
+        statement,
+        statement.modifiers.filter((modifier) => modifier.kind !== ts2.SyntaxKind.ExportKeyword),
+        statement.asteriskToken,
+        localName,
+        statement.typeParameters,
+        statement.parameters,
+        statement.type,
+        statement.body
+      ), exportHandler(name, localName)];
+    }
+    if (ts2.isVariableStatement(statement) && statement.modifiers?.some((modifier) => modifier.kind === ts2.SyntaxKind.ExportKeyword)) {
+      const declarations = statement.declarationList.declarations.map((declaration) => {
+        if (!ts2.isIdentifier(declaration.name) || !METHODS.has(declaration.name.text) || !declaration.initializer) return declaration;
+        changed = true;
+        return ts2.factory.updateVariableDeclaration(
+          declaration,
+          declaration.name,
+          declaration.exclamationToken,
+          declaration.type,
+          wrap(declaration.initializer)
+        );
+      });
+      return [ts2.factory.updateVariableStatement(
+        statement,
+        statement.modifiers,
+        ts2.factory.updateVariableDeclarationList(statement.declarationList, declarations)
+      )];
+    }
+    if (ts2.isExportDeclaration(statement) && statement.exportClause && ts2.isNamedExports(statement.exportClause)) {
+      const handlers = statement.exportClause.elements.filter((element) => METHODS.has(element.name.text));
+      if (handlers.length === 0) return [statement];
+      changed = true;
+      const result = [];
+      const remaining = statement.exportClause.elements.filter((element) => !METHODS.has(element.name.text));
+      if (remaining.length) result.push(ts2.factory.updateExportDeclaration(
+        statement,
+        statement.modifiers,
+        statement.isTypeOnly,
+        ts2.factory.updateNamedExports(statement.exportClause, remaining),
+        statement.moduleSpecifier,
+        statement.attributes
+      ));
+      for (const handler of handlers) {
+        const imported = handler.propertyName ?? handler.name;
+        const local = ts2.factory.createIdentifier(statement.moduleSpecifier ? `__holoOriginal${handler.name.text}` : imported.text);
+        if (statement.moduleSpecifier) result.push(ts2.factory.createImportDeclaration(
+          void 0,
+          ts2.factory.createImportClause(false, void 0, ts2.factory.createNamedImports([
+            ts2.factory.createImportSpecifier(false, imported, local)
+          ])),
+          statement.moduleSpecifier
+        ));
+        result.push(exportHandler(handler.name.text, local));
+      }
+      return result;
+    }
+    return [statement];
+  });
+  if (!changed) return source;
+  const runtimeImport = ts2.factory.createImportDeclaration(
+    void 0,
+    ts2.factory.createImportClause(false, void 0, ts2.factory.createNamedImports([
+      ts2.factory.createImportSpecifier(false, ts2.factory.createIdentifier("adapterNextRuntimeInternals"), ts2.factory.createIdentifier(runtimeName))
+    ])),
+    ts2.factory.createStringLiteral("@holo-js/adapter-next/runtime")
+  );
+  return ts2.createPrinter().printFile(ts2.factory.updateSourceFile(file, [runtimeImport, ...statements]));
+}
+
 // src/build.ts
 function propertyName(property) {
   if (!("name" in property) || !property.name) return void 0;
-  return ts2.isIdentifier(property.name) || ts2.isStringLiteral(property.name) ? property.name.text : void 0;
+  return ts3.isIdentifier(property.name) || ts3.isStringLiteral(property.name) ? property.name.text : void 0;
 }
 function collectRealtimeFactories(sourceFile) {
   const factories = /* @__PURE__ */ new Map([
@@ -154,9 +251,9 @@ function collectRealtimeFactories(sourceFile) {
     ["mutation", "mutation"]
   ]);
   for (const statement of sourceFile.statements) {
-    if (!ts2.isImportDeclaration(statement) || !statement.importClause?.namedBindings) continue;
-    if (!ts2.isStringLiteral(statement.moduleSpecifier) || statement.moduleSpecifier.text !== "@holo-js/realtime") continue;
-    if (!ts2.isNamedImports(statement.importClause.namedBindings)) continue;
+    if (!ts3.isImportDeclaration(statement) || !statement.importClause?.namedBindings) continue;
+    if (!ts3.isStringLiteral(statement.moduleSpecifier) || statement.moduleSpecifier.text !== "@holo-js/realtime") continue;
+    if (!ts3.isNamedImports(statement.importClause.namedBindings)) continue;
     for (const element of statement.importClause.namedBindings.elements) {
       const importedName = element.propertyName?.text ?? element.name.text;
       if (importedName === "query" || importedName === "mutation") {
@@ -170,17 +267,17 @@ function collectDefinitions(sourceFile) {
   const definitions = [];
   const factories = collectRealtimeFactories(sourceFile);
   for (const statement of sourceFile.statements) {
-    if (!ts2.isVariableStatement(statement) || !statement.modifiers?.some((modifier) => modifier.kind === ts2.SyntaxKind.ExportKeyword)) continue;
+    if (!ts3.isVariableStatement(statement) || !statement.modifiers?.some((modifier) => modifier.kind === ts3.SyntaxKind.ExportKeyword)) continue;
     for (const declaration of statement.declarationList.declarations) {
-      if (!ts2.isIdentifier(declaration.name) || !declaration.initializer || !ts2.isCallExpression(declaration.initializer)) continue;
+      if (!ts3.isIdentifier(declaration.name) || !declaration.initializer || !ts3.isCallExpression(declaration.initializer)) continue;
       const factoryNode = declaration.initializer.expression;
-      if (!ts2.isIdentifier(factoryNode)) continue;
+      if (!ts3.isIdentifier(factoryNode)) continue;
       const factory = factories.get(factoryNode.text);
       if (!factory) continue;
       const definitionNode = declaration.initializer.arguments[0];
-      if (!definitionNode || !ts2.isObjectLiteralExpression(definitionNode)) continue;
+      if (!definitionNode || !ts3.isObjectLiteralExpression(definitionNode)) continue;
       const nameProperty = definitionNode.properties.find((property) => propertyName(property) === "name");
-      const name = nameProperty && ts2.isPropertyAssignment(nameProperty) ? nameProperty.initializer.getText(sourceFile) : void 0;
+      const name = nameProperty && ts3.isPropertyAssignment(nameProperty) ? nameProperty.initializer.getText(sourceFile) : void 0;
       const sourceLine = sourceFile.getLineAndCharacterOfPosition(declaration.getStart(sourceFile)).line;
       definitions.push({ exportedName: declaration.name.text, factory, sourceLine, ...name ? { name } : {} });
     }
@@ -217,36 +314,36 @@ function createSourceMap(source, sourceLines) {
   };
 }
 function parseRealtimeSource(source) {
-  const result = ts2.transpileModule(source, {
-    compilerOptions: { module: ts2.ModuleKind.ESNext, target: ts2.ScriptTarget.ESNext },
+  const result = ts3.transpileModule(source, {
+    compilerOptions: { module: ts3.ModuleKind.ESNext, target: ts3.ScriptTarget.ESNext },
     reportDiagnostics: true
   });
-  const diagnostic = result.diagnostics?.find((entry) => entry.category === ts2.DiagnosticCategory.Error);
+  const diagnostic = result.diagnostics?.find((entry) => entry.category === ts3.DiagnosticCategory.Error);
   if (diagnostic) {
-    throw new SyntaxError(ts2.flattenDiagnosticMessageText(diagnostic.messageText, "\n"));
+    throw new SyntaxError(ts3.flattenDiagnosticMessageText(diagnostic.messageText, "\n"));
   }
-  return ts2.createSourceFile("realtime.ts", source, ts2.ScriptTarget.Latest, true, ts2.ScriptKind.TS);
+  return ts3.createSourceFile("realtime.ts", source, ts3.ScriptTarget.Latest, true, ts3.ScriptKind.TS);
 }
 function retargetRealtimeImports(source, importTarget) {
   const sourceFile = parseRealtimeSource(source);
   const transformer = (context) => (root) => {
     const visit = (node) => {
-      if (ts2.isImportDeclaration(node) && ts2.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text === "@holo-js/realtime") {
-        return ts2.factory.updateImportDeclaration(
+      if (ts3.isImportDeclaration(node) && ts3.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text === "@holo-js/realtime") {
+        return ts3.factory.updateImportDeclaration(
           node,
           node.modifiers,
           node.importClause,
-          ts2.factory.createStringLiteral(importTarget),
+          ts3.factory.createStringLiteral(importTarget),
           node.attributes
         );
       }
-      return ts2.visitEachChild(node, visit, context);
+      return ts3.visitEachChild(node, visit, context);
     };
-    return ts2.visitNode(root, visit);
+    return ts3.visitNode(root, visit);
   };
-  const result = ts2.transform(sourceFile, [transformer]);
+  const result = ts3.transform(sourceFile, [transformer]);
   try {
-    return ts2.createPrinter({ newLine: ts2.NewLineKind.LineFeed }).printFile(result.transformed[0]);
+    return ts3.createPrinter({ newLine: ts3.NewLineKind.LineFeed }).printFile(result.transformed[0]);
   } finally {
     result.dispose();
   }
@@ -255,19 +352,19 @@ function stripRealtimeServerHandlers(source) {
   const sourceFile = parseRealtimeSource(source);
   const transformer = (context) => (root) => {
     const visit = (node) => {
-      if (ts2.isPropertyAssignment(node) && (propertyName(node) === "handler" || propertyName(node) === "authorize")) {
-        return ts2.factory.updatePropertyAssignment(node, node.name, ts2.factory.createIdentifier("undefined"));
+      if (ts3.isPropertyAssignment(node) && (propertyName(node) === "handler" || propertyName(node) === "authorize")) {
+        return ts3.factory.updatePropertyAssignment(node, node.name, ts3.factory.createIdentifier("undefined"));
       }
-      if (ts2.isMethodDeclaration(node) && (propertyName(node) === "handler" || propertyName(node) === "authorize")) {
-        return ts2.factory.createPropertyAssignment(node.name, ts2.factory.createIdentifier("undefined"));
+      if (ts3.isMethodDeclaration(node) && (propertyName(node) === "handler" || propertyName(node) === "authorize")) {
+        return ts3.factory.createPropertyAssignment(node.name, ts3.factory.createIdentifier("undefined"));
       }
-      return ts2.visitEachChild(node, visit, context);
+      return ts3.visitEachChild(node, visit, context);
     };
-    return ts2.visitNode(root, visit);
+    return ts3.visitNode(root, visit);
   };
-  const result = ts2.transform(sourceFile, [transformer]);
+  const result = ts3.transform(sourceFile, [transformer]);
   try {
-    return ts2.createPrinter({ newLine: ts2.NewLineKind.LineFeed }).printFile(result.transformed[0]);
+    return ts3.createPrinter({ newLine: ts3.NewLineKind.LineFeed }).printFile(result.transformed[0]);
   } finally {
     result.dispose();
   }
@@ -318,6 +415,7 @@ function createRealtimeClientDefinitionTransform(source, importTarget, options =
 
 export {
   compileBrowserValidation,
+  compileNextRoute,
   stripRealtimeServerHandlers,
   createRealtimeClientDefinitionModule,
   createRealtimeClientDefinitionTransform

package/dist/index.d.ts

@@ -1,3 +1,3 @@
 export { HoloHttpErrorStatus, NormalizedHoloHttpError, isHoloHttpErrorStatus, normalizeHoloHttpError } from '@holo-js/kernel/http-errors';
 export { ClientErrorPageOptions, renderClientHttpErrorPage } from './client.js';
-export { RealtimeDefinitionSourceMap, RealtimeDefinitionTransformOptions, RealtimeDefinitionTransformResult, compileBrowserValidation, createRealtimeClientDefinitionModule, createRealtimeClientDefinitionTransform, stripRealtimeServerHandlers } from './build.js';
+export { RealtimeDefinitionSourceMap, RealtimeDefinitionTransformOptions, RealtimeDefinitionTransformResult, compileBrowserValidation, compileNextRoute, createRealtimeClientDefinitionModule, createRealtimeClientDefinitionTransform, stripRealtimeServerHandlers } from './build.js';

package/dist/index.mjs

@@ -5,12 +5,14 @@ import {
 } from "./chunk-3GNER7MY.mjs";
 import {
   compileBrowserValidation,
+  compileNextRoute,
   createRealtimeClientDefinitionModule,
   createRealtimeClientDefinitionTransform,
   stripRealtimeServerHandlers
-} from "./chunk-4DGYQBYZ.mjs";
+} from "./chunk-6FHRFQPC.mjs";
 export {
   compileBrowserValidation,
+  compileNextRoute,
   createRealtimeClientDefinitionModule,
   createRealtimeClientDefinitionTransform,
   isHoloHttpErrorStatus,

package/dist/server-errors.d.ts

@@ -0,0 +1,15 @@
+type RateLimitFailure = {
+    readonly ok: false;
+    readonly valid: false;
+    readonly status: 429;
+    readonly bag: 'default';
+    readonly message: string;
+    readonly errors: {
+        readonly _root: readonly string[];
+    };
+    readonly values: Readonly<Record<string, never>>;
+    readonly retryAfterSeconds?: number;
+};
+declare function serializeRateLimitError(error: unknown): RateLimitFailure | undefined;
+
+export { serializeRateLimitError };

package/dist/server-errors.mjs

@@ -0,0 +1,24 @@
+// src/server-errors.ts
+import { normalizeHoloHttpError } from "@holo-js/kernel/http-errors";
+function serializeRateLimitError(error) {
+  const normalized = normalizeHoloHttpError(error);
+  if (!normalized || normalized.status !== 429) return void 0;
+  const retryAfterSeconds = error && typeof error === "object" && "retryAfterSeconds" in error && typeof error.retryAfterSeconds === "number" && Number.isFinite(error.retryAfterSeconds) ? error.retryAfterSeconds : void 0;
+  if (retryAfterSeconds === void 0 && error && typeof error === "object" && "cause" in error) {
+    const cause = serializeRateLimitError(error.cause);
+    if (cause) return cause;
+  }
+  return {
+    ok: false,
+    valid: false,
+    status: 429,
+    bag: "default",
+    message: normalized.message,
+    errors: { _root: [normalized.message] },
+    values: {},
+    ...retryAfterSeconds === void 0 ? {} : { retryAfterSeconds }
+  };
+}
+export {
+  serializeRateLimitError
+};

package/package.json

@@ -1,10 +1,15 @@
 {
   "name": "@holo-js/adapter-shared",
-  "version": "0.3.19",
+  "version": "0.3.20",
   "description": "Holo-JS Framework - shared framework adapter infrastructure",
   "type": "module",
   "license": "MIT",
   "exports": {
+    "./server-errors": {
+      "types": "./dist/server-errors.d.ts",
+      "import": "./dist/server-errors.mjs",
+      "default": "./dist/server-errors.mjs"
+    },
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs",
@@ -46,7 +51,7 @@
     "test": "vitest --run"
   },
   "dependencies": {
-    "@holo-js/kernel": "^0.3.19",
+    "@holo-js/kernel": "^0.3.20",
     "typescript": "^5.7.2"
   },
   "devDependencies": {