@cedarjs/auth-dbauth-web 5.0.7-next.338 → 5.0.7

package/dist/cjs/dbAuth.d.ts

@@ -0,0 +1,42 @@
+import type { CurrentUser } from '@cedarjs/auth';
+import type { WebAuthnClientType } from './webAuthn.js';
+export interface LoginAttributes {
+    username: string;
+    password: string;
+}
+export interface ResetPasswordAttributes {
+    resetToken: string;
+    password: string;
+}
+export type SignupAttributes = Record<string, unknown> & LoginAttributes;
+export declare function createAuth(dbAuthClient: ReturnType<typeof createDbAuthClient>, customProviderHooks?: {
+    useCurrentUser?: () => Promise<CurrentUser>;
+    useHasRole?: (currentUser: CurrentUser | null) => (rolesToCheck: string | string[]) => boolean;
+}): {
+    AuthContext: import("react").Context<import("@cedarjs/auth").AuthContextInterface<string | (() => void), LoginAttributes, any, unknown, boolean, SignupAttributes, any, any, ResetPasswordAttributes, any, any, import("./webAuthn.js").default> | undefined>;
+    AuthProvider: ({ children }: import("@cedarjs/auth").AuthProviderProps) => import("react").JSX.Element;
+    useAuth: () => import("@cedarjs/auth").AuthContextInterface<string | (() => void), LoginAttributes, any, unknown, boolean, SignupAttributes, any, any, ResetPasswordAttributes, any, any, import("./webAuthn.js").default>;
+};
+export interface DbAuthClientArgs {
+    webAuthn?: InstanceType<WebAuthnClientType>;
+    dbAuthUrl?: string;
+    fetchConfig?: {
+        credentials?: 'include' | 'same-origin';
+    };
+    middleware?: boolean;
+}
+export declare function createDbAuthClient({ webAuthn, dbAuthUrl, fetchConfig, middleware, }?: DbAuthClientArgs): {
+    type: string;
+    client: import("./webAuthn.js").default | undefined;
+    login: ({ username, password }: LoginAttributes) => Promise<any>;
+    logout: () => Promise<boolean>;
+    signup: (attributes: SignupAttributes) => Promise<any>;
+    getToken: () => Promise<string | null>;
+    getUserMetadata: () => Promise<string | (() => void) | null>;
+    forgotPassword: (username: string) => Promise<any>;
+    resetPassword: (attributes: ResetPasswordAttributes) => Promise<any>;
+    validateResetToken: (resetToken: string | null) => Promise<any>;
+    getAuthUrl: () => string;
+    middlewareAuthEnabled: boolean;
+};
+//# sourceMappingURL=dbAuth.d.ts.map

package/dist/cjs/dbAuth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dbAuth.d.ts","sourceRoot":"","sources":["../../src/dbAuth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAuB,MAAM,eAAe,CAAA;AAMrE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAA;AAEvD,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,uBAAuB;IACtC,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,eAAe,CAAA;AAkBxE,wBAAgB,UAAU,CACxB,YAAY,EAAE,UAAU,CAAC,OAAO,kBAAkB,CAAC,EACnD,mBAAmB,CAAC,EAAE;IACpB,cAAc,CAAC,EAAE,MAAM,OAAO,CAAC,WAAW,CAAC,CAAA;IAC3C,UAAU,CAAC,EAAE,CACX,WAAW,EAAE,WAAW,GAAG,IAAI,KAC5B,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,EAAE,KAAK,OAAO,CAAA;CAClD;;;;EAOF;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,EAAE,YAAY,CAAC,kBAAkB,CAAC,CAAA;IAC3C,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,WAAW,CAAC,EAAE;QACZ,WAAW,CAAC,EAAE,SAAS,GAAG,aAAa,CAAA;KACxC,CAAA;IACD,UAAU,CAAC,EAAE,OAAO,CAAA;CACrB;AAED,wBAAgB,kBAAkB,CAAC,EACjC,QAAQ,EACR,SAAS,EACT,WAAW,EACX,UAA4C,GAC7C,GAAE,gBAAqB;;;oCA6EuB,eAAe;;yBAgC1B,gBAAgB;;;+BA9EV,MAAM;gCAmEL,uBAAuB;qCAsBlB,MAAM,GAAG,IAAI;;;EAoC5D"}

package/dist/cjs/dbAuth.js

@@ -0,0 +1,170 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dbAuth_exports = {};
+__export(dbAuth_exports, {
+  createAuth: () => createAuth,
+  createDbAuthClient: () => createDbAuthClient
+});
+module.exports = __toCommonJS(dbAuth_exports);
+var import_auth = require("@cedarjs/auth");
+const TOKEN_CACHE_TIME = 5e3;
+function createMiddlewareAuth(dbAuthClient, customProviderHooks) {
+  return (0, import_auth.createAuthentication)(dbAuthClient, {
+    ...customProviderHooks,
+    useCurrentUser: customProviderHooks?.useCurrentUser ?? (() => (0, import_auth.getCurrentUserFromMiddleware)(dbAuthClient.getAuthUrl()))
+  });
+}
+function createAuth(dbAuthClient, customProviderHooks) {
+  if (dbAuthClient.middlewareAuthEnabled) {
+    return createMiddlewareAuth(dbAuthClient, customProviderHooks);
+  }
+  return (0, import_auth.createAuthentication)(dbAuthClient, customProviderHooks);
+}
+function createDbAuthClient({
+  webAuthn,
+  dbAuthUrl,
+  fetchConfig,
+  middleware = RWJS_ENV.RWJS_EXP_STREAMING_SSR
+} = {}) {
+  const credentials = fetchConfig?.credentials || "same-origin";
+  webAuthn?.setAuthApiUrl(dbAuthUrl);
+  let getTokenPromise;
+  let lastTokenCheckAt = /* @__PURE__ */ new Date("1970-01-01T00:00:00");
+  let cachedToken;
+  const getDbAuthUrl = () => {
+    if (dbAuthUrl) {
+      return dbAuthUrl;
+    }
+    return middleware ? `/middleware/dbauth` : `${RWJS_API_URL}/auth`;
+  };
+  const resetAndFetch = async (...params) => {
+    resetTokenCache();
+    return fetch(...params);
+  };
+  const isTokenCacheExpired = () => {
+    const now = /* @__PURE__ */ new Date();
+    return now.getTime() - lastTokenCheckAt.getTime() > TOKEN_CACHE_TIME;
+  };
+  const resetTokenCache = () => {
+    lastTokenCheckAt = /* @__PURE__ */ new Date("1970-01-01T00:00:00");
+    cachedToken = null;
+  };
+  const forgotPassword = async (username) => {
+    const response = await resetAndFetch(getDbAuthUrl(), {
+      credentials,
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ username, method: "forgotPassword" })
+    });
+    return response.json();
+  };
+  const getToken = async () => {
+    if (middleware) {
+      return null;
+    }
+    if (getTokenPromise) {
+      return getTokenPromise;
+    }
+    if (isTokenCacheExpired()) {
+      getTokenPromise = fetch(`${getDbAuthUrl()}?method=getToken`, {
+        credentials
+      }).then((response) => response.text()).then((tokenText) => {
+        lastTokenCheckAt = /* @__PURE__ */ new Date();
+        cachedToken = tokenText.length === 0 ? null : tokenText;
+        return cachedToken;
+      }).catch(() => {
+        return null;
+      }).finally(() => {
+        getTokenPromise = null;
+      });
+      return getTokenPromise;
+    }
+    return cachedToken;
+  };
+  const login = async ({ username, password }) => {
+    const response = await resetAndFetch(getDbAuthUrl(), {
+      credentials,
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ username, password, method: "login" })
+    });
+    return response.json();
+  };
+  const logout = async () => {
+    await resetAndFetch(getDbAuthUrl(), {
+      credentials,
+      method: "POST",
+      body: JSON.stringify({ method: "logout" })
+    });
+    return true;
+  };
+  const resetPassword = async (attributes) => {
+    const response = await resetAndFetch(getDbAuthUrl(), {
+      credentials,
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ ...attributes, method: "resetPassword" })
+    });
+    return response.json();
+  };
+  const signup = async (attributes) => {
+    const response = await resetAndFetch(getDbAuthUrl(), {
+      credentials,
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ ...attributes, method: "signup" })
+    });
+    return response.json();
+  };
+  const validateResetToken = async (resetToken) => {
+    const response = await resetAndFetch(getDbAuthUrl(), {
+      credentials,
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ resetToken, method: "validateResetToken" })
+    });
+    return response.json();
+  };
+  const getUserMetadata = async () => {
+    return middleware ? () => {
+    } : getToken();
+  };
+  return {
+    type: "dbAuth",
+    client: webAuthn,
+    login,
+    logout,
+    signup,
+    getToken,
+    getUserMetadata,
+    forgotPassword,
+    resetPassword,
+    validateResetToken,
+    // New methods for middleware auth:
+    // This is so we can get the dbAuthUrl in getCurrentUserFromMiddleware
+    getAuthUrl: getDbAuthUrl,
+    // This is so that we can skip fetching getCurrentUser in reauthenticate
+    middlewareAuthEnabled: middleware
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createAuth,
+  createDbAuthClient
+});

package/dist/cjs/index.d.ts

@@ -0,0 +1,2 @@
+export * from './dbAuth.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA"}

package/dist/cjs/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var index_exports = {};
+module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, require("./dbAuth.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./dbAuth.js")
+});

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/cjs/webAuthn.d.ts

@@ -0,0 +1,13 @@
+export default class WebAuthnClient {
+    authApiUrl: string;
+    private getAuthApiUrl;
+    setAuthApiUrl(authApiUrl?: string): void;
+    isSupported(): Promise<any>;
+    isEnabled(): boolean;
+    private authenticationOptions;
+    authenticate(): Promise<boolean>;
+    private registrationOptions;
+    register(): Promise<boolean>;
+}
+export type WebAuthnClientType = typeof WebAuthnClient;
+//# sourceMappingURL=webAuthn.d.ts.map

package/dist/cjs/webAuthn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webAuthn.d.ts","sourceRoot":"","sources":["../../src/webAuthn.ts"],"names":[],"mappings":"AAqCA,MAAM,CAAC,OAAO,OAAO,cAAc;IACjC,UAAU,SAAK;IAEf,OAAO,CAAC,aAAa;IAIrB,aAAa,CAAC,UAAU,CAAC,EAAE,MAAM;IAM3B,WAAW;IAKjB,SAAS;YAQK,qBAAqB;IAmC7B,YAAY;IA0ClB,OAAO,CAAC,mBAAmB;IA+BrB,QAAQ;CAwCf;AAED,MAAM,MAAM,kBAAkB,GAAG,OAAO,cAAc,CAAA"}

package/dist/cjs/webAuthn.js

@@ -0,0 +1,210 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var webAuthn_exports = {};
+__export(webAuthn_exports, {
+  default: () => WebAuthnClient
+});
+module.exports = __toCommonJS(webAuthn_exports);
+class WebAuthnRegistrationError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WebAuthnRegistrationError";
+  }
+}
+class WebAuthnAuthenticationError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WebAuthnAuthenticationError";
+  }
+}
+class WebAuthnAlreadyRegisteredError extends WebAuthnRegistrationError {
+  constructor() {
+    super("This device is already registered");
+    this.name = "WebAuthnAlreadyRegisteredError";
+  }
+}
+class WebAuthnDeviceNotFoundError extends WebAuthnAuthenticationError {
+  constructor() {
+    super("WebAuthn device not found");
+    this.name = "WebAuthnDeviceNotFoundError";
+  }
+}
+class WebAuthnNoAuthenticatorError extends WebAuthnAuthenticationError {
+  constructor() {
+    super(
+      "This device was not recognized. Use username/password login, or if you're using iOS you can try reloading this page"
+    );
+    this.name = "WebAuthnNoAuthenticatorError";
+  }
+}
+class WebAuthnClient {
+  authApiUrl = "";
+  getAuthApiUrl() {
+    return this.authApiUrl || `${RWJS_API_URL}/auth`;
+  }
+  setAuthApiUrl(authApiUrl) {
+    if (authApiUrl) {
+      this.authApiUrl = authApiUrl;
+    }
+  }
+  async isSupported() {
+    const { browserSupportsWebAuthn } = await import("@simplewebauthn/browser");
+    return browserSupportsWebAuthn();
+  }
+  isEnabled() {
+    if (typeof window === "undefined") {
+      return false;
+    }
+    return !!/\bwebAuthn\b/.test(document.cookie);
+  }
+  async authenticationOptions() {
+    let options;
+    try {
+      const xhr = new XMLHttpRequest();
+      xhr.withCredentials = true;
+      xhr.open(
+        "GET",
+        `${this.getAuthApiUrl()}?method=webAuthnAuthOptions`,
+        false
+      );
+      xhr.setRequestHeader("content-type", "application/json");
+      xhr.send(null);
+      options = JSON.parse(xhr.responseText);
+      if (xhr.status !== 200) {
+        if (options.error?.match(/username and password/)) {
+          throw new WebAuthnDeviceNotFoundError();
+        } else {
+          throw new WebAuthnAuthenticationError(
+            `Could not start authentication: ${options.error}`
+          );
+        }
+      }
+    } catch (e) {
+      console.error(e.message);
+      throw new WebAuthnAuthenticationError(
+        `Could not start authentication: ${e.message}`
+      );
+    }
+    return options;
+  }
+  async authenticate() {
+    const authOptions = await this.authenticationOptions();
+    const { startAuthentication } = await import("@simplewebauthn/browser");
+    try {
+      const browserResponse = await startAuthentication(authOptions);
+      const xhr = new XMLHttpRequest();
+      xhr.withCredentials = true;
+      xhr.open("POST", this.getAuthApiUrl(), false);
+      xhr.setRequestHeader("content-type", "application/json");
+      xhr.send(
+        JSON.stringify({
+          method: "webAuthnAuthenticate",
+          ...browserResponse
+        })
+      );
+      const options = JSON.parse(xhr.responseText);
+      if (xhr.status !== 200) {
+        throw new WebAuthnAuthenticationError(
+          `Could not complete authentication: ${options.error}`
+        );
+      }
+    } catch (e) {
+      if (e.message.match(
+        /No available authenticator recognized any of the allowed credentials/
+      )) {
+        throw new WebAuthnNoAuthenticatorError();
+      } else {
+        throw new WebAuthnAuthenticationError(
+          `Error while authenticating: ${e.message}`
+        );
+      }
+    }
+    return true;
+  }
+  registrationOptions() {
+    let options;
+    try {
+      const xhr = new XMLHttpRequest();
+      xhr.withCredentials = true;
+      xhr.open(
+        "GET",
+        `${this.getAuthApiUrl()}?method=webAuthnRegOptions`,
+        false
+      );
+      xhr.setRequestHeader("content-type", "application/json");
+      xhr.send(null);
+      options = JSON.parse(xhr.responseText);
+      if (xhr.status !== 200) {
+        throw new WebAuthnRegistrationError(
+          `Could not start registration: ${options.error}`
+        );
+      }
+    } catch (e) {
+      console.error(e);
+      throw new WebAuthnRegistrationError(
+        `Could not start registration: ${e.message}`
+      );
+    }
+    return options;
+  }
+  async register() {
+    const options = await this.registrationOptions();
+    let regResponse;
+    const { startRegistration } = await import("@simplewebauthn/browser");
+    try {
+      regResponse = await startRegistration(options);
+    } catch (e) {
+      if (e.name === "InvalidStateError") {
+        throw new WebAuthnAlreadyRegisteredError();
+      } else {
+        throw new WebAuthnRegistrationError(
+          `Error while registering: ${e.message}`
+        );
+      }
+    }
+    try {
+      const xhr = new XMLHttpRequest();
+      xhr.withCredentials = true;
+      xhr.open("POST", this.getAuthApiUrl(), false);
+      xhr.setRequestHeader("content-type", "application/json");
+      xhr.send(JSON.stringify({ method: "webAuthnRegister", ...regResponse }));
+      const options2 = JSON.parse(xhr.responseText);
+      if (xhr.status !== 200) {
+        throw new WebAuthnRegistrationError(
+          `Could not complete registration: ${options2.error}`
+        );
+      }
+    } catch (e) {
+      throw new WebAuthnRegistrationError(
+        `Error while registering: ${e.message}`
+      );
+    }
+    return true;
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cedarjs/auth-dbauth-web",
-  "version": "5.0.7-next.338",
+  "version": "5.0.7",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/cedarjs/cedar.git",
@@ -10,27 +10,28 @@
   "type": "module",
   "exports": {
     ".": {
-      "default": {
+      "import": {
         "types": "./dist/index.d.ts",
         "default": "./dist/index.js"
-      }
-    },
-    "./webAuthn": {
+      },
       "default": {
-        "types": "./dist/webAuthn.d.ts",
-        "default": "./dist/webAuthn.js"
+        "types": "./dist/cjs/index.d.ts",
+        "default": "./dist/cjs/index.js"
       }
     }
   },
-  "main": "./dist/index.js",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [
-    "dist"
+    "dist",
+    "webAuthn"
   ],
   "scripts": {
     "build": "node ./build.ts",
     "build:pack": "yarn pack -o cedarjs-auth-dbauth-web.tgz",
     "build:types": "tsc --build --verbose ./tsconfig.build.json",
+    "build:types-cjs": "tsc --build --verbose ./tsconfig.cjs.json",
     "build:watch": "nodemon --watch src --ext \"js,jsx,ts,tsx,template\" --ignore dist --exec \"yarn build\"",
     "check:attw": "yarn cedar-fwtools-attw",
     "check:package": "concurrently npm:check:attw yarn:publint",
@@ -39,17 +40,19 @@
     "test:watch": "vitest watch"
   },
   "dependencies": {
-    "@cedarjs/auth": "5.0.7-next.338",
+    "@cedarjs/auth": "5.0.7",
     "@simplewebauthn/browser": "10.0.0"
   },
   "devDependencies": {
-    "@cedarjs/framework-tools": "5.0.7-next.338",
+    "@arethetypeswrong/cli": "0.18.4",
+    "@cedarjs/framework-tools": "5.0.7",
+    "@simplewebauthn/types": "10.0.0",
     "@types/react": "^18.2.55",
     "concurrently": "9.2.4",
-    "publint": "0.3.23",
+    "publint": "0.3.21",
     "react": "18.3.1",
     "typescript": "5.9.3",
-    "vitest": "4.1.10"
+    "vitest": "3.2.6"
   },
   "engines": {
     "node": ">=24"

package/webAuthn/index.js

@@ -0,0 +1,2 @@
+// For CommonJS environments, point to the CJS build
+module.exports = require('../dist/cjs/webAuthn')

package/webAuthn/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "./index.js",
+  "types": "../dist/cjs/webAuthn.d.ts"
+}