@faable/auth-sdk 2.6.23 → 2.7.1

package/dist/helpers.js

@@ -1,4 +1,4 @@
-import { FaableApiError } from "./error_handler.js";
+import { FaableApiError } from "@faable/sdk-base";
 // Normaliza el `domain` para que dé igual cómo lo pase el usuario: con o sin
 // protocolo, con trailing slash, o incluso con protocolo duplicado (el valor
 // que el dashboard copia ya trae `https://`). Siempre devuelve

package/dist/index.d.ts

@@ -3,5 +3,5 @@ export { SDK_CLIENT, commit, version } from "./version.js";
 export * from "./api/generated-client.js";
 export * from "./api/api-types.js";
 export * from "./api/types.js";
-export { authClientCredentials, authApikey, authBearer, authCookie, } from "@faable/sdk-base";
+export { authClientCredentials, authApikey, authBearer, authCookie, FaableApiError, } from "@faable/sdk-base";
 export type { ApiParams, ClientCredentialsConfig, ApikeyConfig, BearerConfig, RetryConfig, Fetcher, FetcherConfig, FetcherRequestParams, AuthStrategy, AuthStrategyBuilder, AuthStrategyContext, } from "@faable/sdk-base";

package/dist/index.js

@@ -6,4 +6,8 @@ export * from "./api/types.js";
 // Re-export the auth strategies (and their config/types) from
 // @faable/sdk-base so consumers depend on @faable/auth-sdk ONLY — sdk-base
 // stays a transitive dependency and no app needs to import it directly.
-export { authClientCredentials, authApikey, authBearer, authCookie, } from "@faable/sdk-base";
+export { authClientCredentials, authApikey, authBearer, authCookie, 
+// The error every method throws on a non-2xx. Branch on `err.error_code`
+// (or `err.isErrorCode('sms_unavailable')`), never on `err.message`: the
+// generated client lists the codes of each method as `@throws`.
+FaableApiError, } from "@faable/sdk-base";

package/dist/version.js

@@ -9,13 +9,13 @@
 // login pages could not import the SDK at all. Same pattern as auth-js.
 //
 // The sentinels MUST stay byte-identical to the `from` values in `.releaserc`.
-export const version = "2.6.23";
+export const version = "2.7.1";
 // Short git SHA of the released commit. The version dates a build; this names
 // the exact tree, so a canonical log line or an audit entry leads straight to
 // `git show <sha>`. Deliberately NOT hex: an unreleased build (dev, a local
 // link) cannot be mistaken for a real commit — auth only records values that
 // look like a SHA, and this one never will.
-export const commit = "65b2a2d";
+export const commit = "2271aa1";
 // What this SDK writes in `x-faable-client`. Exported for a consumer that
 // builds a strategy on its own (outside `FaableAuthApi`) and still wants the
 // token request attributed — a bare `authClientCredentials` stamps only what

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@faable/auth-sdk",
-  "version": "2.6.23",
+  "version": "2.7.1",
   "author": "Marc Pomar <marc@faable.com>",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -10,7 +10,7 @@
   },
   "type": "module",
   "dependencies": {
-    "@faable/sdk-base": "^1.6.0"
+    "@faable/sdk-base": "^1.7.0"
   },
   "devDependencies": {
     "@ava/typescript": "^5.0.0",

package/scripts/gen-client.mjs

@@ -80,6 +80,40 @@ for (const [path, methods] of Object.entries(spec.paths || {})) {
 }
 operations.sort((a, b) => a.op.operationId.localeCompare(b.op.operationId));
 
+// Multi-line descriptions become one JSDoc line each.
+const escapeBlock = (text) =>
+  String(text)
+    .split("\n")
+    .map((l) => `   * ${escape(l)}`);
+
+// The server documents each 4xx/5xx as an ErrorResponse whose `error_code`
+// is restricted to an enum, and describes every code in the response
+// description as "`code` — text" lines. Read both back so the docstring can
+// list what a caller may branch on.
+const errorCodesOf = (op) => {
+  const out = [];
+  const seen = new Set();
+  for (const [status, res] of Object.entries(op.responses || {})) {
+    if (!/^[45]\d\d$/.test(status)) continue;
+    const schema = res?.content?.["application/json"]?.schema;
+    const parts = schema?.allOf || (schema ? [schema] : []);
+    const codes = parts.flatMap((p) => p?.properties?.error_code?.enum || []);
+    const descriptions = new Map(
+      String(res?.description || "")
+        .split("\n")
+        .map((l) => l.match(/^`([a-z_]+)` — (.*)$/))
+        .filter(Boolean)
+        .map((m) => [m[1], m[2]]),
+    );
+    for (const code of codes) {
+      if (seen.has(code)) continue;
+      seen.add(code);
+      out.push({ code, status, description: descriptions.get(code) });
+    }
+  }
+  return out;
+};
+
 const emitMethod = ({ path, httpMethod, op }) => {
   const id = op.operationId;
   const name = toMethodName(id);
@@ -128,11 +162,23 @@ const emitMethod = ({ path, httpMethod, op }) => {
   }
 
   const guards = pathParams.map((p) => `    requireId("${p}", ${p});`);
-  const doc = op.summary || op.description;
+  // Summary AND description: the CRUD summaries are generic ("Get User") and
+  // used to hide the prose that actually explains the endpoint.
+  const docLines = [op.summary, op.description]
+    .filter((x, i, all) => x && all.indexOf(x) === i)
+    .flatMap((text, i) => [...(i ? ["   *"] : []), ...escapeBlock(text)]);
+  // One `@throws` per documented error code, read from the 4xx/5xx responses
+  // the server injects (see auth's server/openapi_errors.ts). The code is
+  // `err.error_code` on the FaableApiError the fetcher throws.
+  const throwsLines = errorCodesOf(op).map(
+    ({ code, status, description }) =>
+      `   * @throws {FaableApiError} \`${code}\` (${status})${description ? ` — ${escape(description)}` : ""}`,
+  );
   const jsdoc = [
     "  /**",
     `   * \`${httpMethod.toUpperCase()} ${path}\` — operationId: \`${id}\``,
-    ...(doc ? [`   *`, `   * ${escape(doc)}`] : []),
+    ...(docLines.length ? ["   *", ...docLines] : []),
+    ...(throwsLines.length ? ["   *", ...throwsLines] : []),
     "   */",
   ].join("\n");