@niledatabase/client 5.0.0-alpha.2

package/dist/index.js

@@ -0,0 +1,725 @@
+"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);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Authorizer: () => Authorizer,
+  auth: () => auth,
+  broadcast: () => broadcast,
+  getCsrfToken: () => getCsrfToken,
+  getProviders: () => getProviders,
+  getSession: () => getSession,
+  getStatus: () => getStatus,
+  resetPassword: () => resetPassword,
+  signIn: () => signIn,
+  signOut: () => signOut,
+  signUp: () => signUp
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/logger.ts
+var UnknownError = class extends Error {
+  code;
+  constructor(error) {
+    super(error?.message ?? error);
+    this.name = "UnknownError";
+    this.code = error.code;
+    if (error instanceof Error) {
+      this.stack = error.stack;
+    }
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      stack: this.stack
+    };
+  }
+};
+function formatError(o) {
+  if (o instanceof Error && !(o instanceof UnknownError)) {
+    return JSON.stringify({ message: o.message, stack: o.stack, name: o.name });
+  }
+  if (hasErrorProperty(o)) {
+    o.error = formatError(o.error);
+    o.message = o.message ?? o.error.message;
+  }
+  return o;
+}
+function hasErrorProperty(x) {
+  return !!x?.error;
+}
+var _logger = {
+  error(code, metadata) {
+    metadata = formatError(metadata);
+    console.error(`[nile-auth][error][${code}]`, metadata.message, metadata);
+  },
+  warn(code) {
+    console.warn(`[nile-auth][warn][${code}]`);
+  },
+  debug(code, metadata) {
+    console.log(`[next-auth][debug][${code}]`, metadata);
+  }
+};
+function proxyLogger(logger2 = _logger, authorizer2) {
+  try {
+    if (typeof window === "undefined") {
+      return logger2;
+    }
+    const clientLogger = {};
+    for (const level in logger2) {
+      clientLogger[level] = (code, metadata) => {
+        _logger[level](code, metadata);
+        if (level === "error") {
+          metadata = formatError(metadata);
+        }
+        metadata.client = true;
+        const url = `${authorizer2.state.basePath}/_log`;
+        const body = new URLSearchParams({ level, code, ...metadata });
+        if (navigator.sendBeacon) {
+          return navigator.sendBeacon(url, body);
+        }
+        return fetch(url, { method: "POST", body, keepalive: true });
+      };
+    }
+    return clientLogger;
+  } catch {
+    return _logger;
+  }
+}
+var logger = (authorizer2) => proxyLogger(_logger, authorizer2);
+
+// src/broadcast.ts
+function now() {
+  return Math.floor(Date.now() / 1e3);
+}
+function BroadcastChannel(name = "nextauth.message") {
+  return {
+    /** Get notified by other tabs/windows. */
+    receive(onReceive) {
+      const handler = (event) => {
+        if (event.key !== name) return;
+        const message = JSON.parse(event.newValue ?? "{}");
+        if (message?.event !== "session" || !message?.data) return;
+        onReceive(message);
+      };
+      window.addEventListener("storage", handler);
+      return () => window.removeEventListener("storage", handler);
+    },
+    /** Notify other tabs/windows. */
+    post(message) {
+      if (typeof window === "undefined") return;
+      try {
+        localStorage.setItem(
+          name,
+          JSON.stringify({ ...message, timestamp: now() })
+        );
+      } catch {
+      }
+    }
+  };
+}
+var broadcast = BroadcastChannel();
+
+// src/observable.ts
+function isEqual(a, b) {
+  if (a === b) return true;
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) {
+    return false;
+  }
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) return false;
+  for (const key of keysA) {
+    if (!keysB.includes(key) || !isEqual(a[key], b[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+function createObservableObject(obj, listenerKeys = ["loading", "session"], eventName = "objectChange") {
+  const eventTarget = new EventTarget();
+  const listeners = /* @__PURE__ */ new Map();
+  const handler = {
+    set(target, key, value) {
+      const prev = target[key];
+      target[key] = value;
+      if (isEqual(prev, value)) return true;
+      if (listenerKeys.includes(String(key))) {
+        eventTarget.dispatchEvent(
+          new CustomEvent(eventName, {
+            detail: { key, prev, next: value }
+          })
+        );
+      }
+      return true;
+    }
+  };
+  return {
+    proxy: new Proxy(obj, handler),
+    eventTarget,
+    addListener(callback) {
+      if (listeners.has(callback)) {
+        return;
+      }
+      const wrappedCallback = (e) => callback(e.detail);
+      listeners.set(callback, wrappedCallback);
+      eventTarget.addEventListener(eventName, wrappedCallback);
+    },
+    removeListener(callback) {
+      const wrappedCallback = listeners.get(callback);
+      if (wrappedCallback) {
+        eventTarget.removeEventListener(eventName, wrappedCallback);
+        listeners.delete(callback);
+      }
+    }
+  };
+}
+
+// src/Authorizer.ts
+var Authorizer = class {
+  state;
+  logger;
+  requestInit;
+  addListener;
+  removeListener;
+  status;
+  constructor(config) {
+    const { proxy, addListener, removeListener } = createObservableObject(
+      {
+        basePath: parseUrl(config?.basePath).path,
+        baseUrl: parseUrl(config?.baseUrl).origin,
+        lastSync: 0,
+        getSession: () => void 0,
+        session: void 0,
+        loading: true
+      },
+      config?.listenerKeys,
+      "auth"
+    );
+    this.state = proxy;
+    this.addListener = addListener;
+    this.removeListener = removeListener;
+    this.logger = logger(this);
+    this.status = null;
+  }
+  async sync(event) {
+    try {
+      const storageEvent = event === "storage";
+      if (storageEvent || !this.state.session) {
+        this.state.getSession = await this.getSession;
+        this.state.lastSync = now();
+      }
+      if (!event || this.state.session == null || now() < this.state.lastSync) {
+        return;
+      }
+      this.state.lastSync = Date.now();
+      this.state.session = await this.getSession();
+    } catch (error) {
+      this.logger.error("CLIENT_SESSION_ERROR", error);
+    }
+  }
+  set baseUrl(val) {
+    this.state.baseUrl = val;
+    this.logger = logger(this);
+  }
+  get baseUrl() {
+    this.logger = logger(this);
+    return this.state.baseUrl;
+  }
+  configure(config) {
+    if (config?.basePath) this.state.basePath = parseUrl(config?.basePath).path;
+    if (config?.baseUrl) this.baseUrl = config.baseUrl;
+    if (config?.init) this.requestInit = config.init;
+    return this;
+  }
+  sanitize() {
+    return {
+      state: {
+        baseUrl: this.baseUrl,
+        session: {
+          user: {
+            email: this.state.session?.user?.email
+          }
+        }
+      },
+      requestInit: this.requestInit
+    };
+  }
+  async initialize(params) {
+    const { baseUrl, session, event } = params ?? {};
+    if (baseUrl) this.baseUrl = baseUrl;
+    const hasInitialSession = session !== void 0;
+    this.state.loading = !hasInitialSession;
+    this.state.lastSync = hasInitialSession ? now() : 0;
+    this.state.session = session;
+    await this.sync(event);
+  }
+  get apiBaseUrl() {
+    return `${this.baseUrl}${this.state.basePath}`;
+  }
+  async sendData(url, init) {
+    try {
+      const options = {
+        headers: {
+          "Content-Type": "application/json"
+        },
+        ...this.requestInit ? this.requestInit : {},
+        ...init
+      };
+      const filledUrl = !url.startsWith("http") ? `${window.location.origin}${url}` : url;
+      const res = await fetch(filledUrl, options);
+      this.state.loading = false;
+      return res;
+    } catch (error) {
+      this.logger.error("CLIENT_FETCH_ERROR", { error, url });
+      return void 0;
+    }
+  }
+  async fetchData(url, init) {
+    const options = {
+      ...this.requestInit ? this.requestInit : {},
+      ...init
+    };
+    const res = await this.sendData(url, options);
+    const errorHandler = res?.clone();
+    try {
+      if (res?.ok) {
+        const data = await res.json();
+        this.state.loading = false;
+        if (!res.ok) throw data;
+        return Object.keys(data).length > 0 ? data : void 0;
+      }
+    } catch (error) {
+      if (error instanceof Error) {
+        if (!error.message.includes("is not valid JSON")) {
+          this.logger.error("CLIENT_FETCH_ERROR", {
+            error,
+            url
+          });
+        } else {
+          const error2 = await errorHandler?.text();
+          if (error2) {
+            if (errorHandler) {
+              const urlSearchParams = new URLSearchParams({ error: error2 });
+              return { url: `${url}?${urlSearchParams}` };
+            }
+          }
+        }
+      }
+      return void 0;
+    }
+  }
+  async fetchFormData(url, init) {
+    try {
+      const res = await fetch(url, {
+        ...this.requestInit,
+        ...init,
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded"
+        }
+      });
+      if (res) {
+        if (res.ok) {
+          return {
+            data: await res.json(),
+            status: res.status,
+            ok: res.ok,
+            url: res.url
+          };
+        }
+        const { url: responseUrl } = await res.json();
+        return {
+          data: {},
+          status: res.status,
+          ok: res?.ok,
+          url: responseUrl
+        };
+      }
+      throw new Error(`Unable to fetch ${url}`);
+    } catch (error) {
+      if (error instanceof Error) {
+        if (!error.message.includes("is not valid JSON")) {
+          this.logger.error("CLIENT_FETCH_ERROR", {
+            error,
+            url
+          });
+        }
+      }
+      return void 0;
+    }
+  }
+  async getProviders(url) {
+    return await this.fetchData(url ?? `${this.apiBaseUrl}/auth/providers`);
+  }
+  async getCsrfToken(url) {
+    const response = await this.fetchData(
+      url ?? `${this.apiBaseUrl}/auth/csrf`
+    );
+    return response?.csrfToken;
+  }
+  async getSession(params) {
+    if (this.status === "getSession" /* SESSION */) {
+      return;
+    }
+    this.status = "getSession" /* SESSION */;
+    if (params?.init) {
+      this.requestInit = params.init;
+    }
+    if (params?.baseUrl) {
+      this.baseUrl = params.baseUrl;
+    }
+    if (this.state.session && now() < this.state.lastSync) {
+      this.status = null;
+      return this.state.session;
+    }
+    this.state.loading = true;
+    const session = await this.fetchData(
+      `${this.apiBaseUrl}/auth/session`
+    );
+    broadcast.post({ event: "session", data: { trigger: "getSession" } });
+    this.status = null;
+    if (session) {
+      this.state.session = session;
+      await this.sync("storage");
+      return { ...session, loading: this.state.loading };
+    }
+    return { loading: this.state.loading };
+  }
+  async refreshSession() {
+    this.state.loading = true;
+    const session = await this.fetchData(
+      `${this.apiBaseUrl}/auth/session`
+    );
+    broadcast.post({ event: "session", data: { trigger: "getSession" } });
+    this.state.session = session;
+    await this.sync("storage");
+    return session;
+  }
+  async signOut(options) {
+    const {
+      callbackUrl = window.location.href,
+      baseUrl,
+      auth: auth2,
+      fetchUrl,
+      basePath
+    } = options ?? {};
+    if (basePath) {
+      this.state.basePath = basePath;
+    }
+    if (baseUrl) {
+      this.baseUrl = baseUrl;
+    }
+    if (auth2) {
+      this.requestInit = auth2.requestInit;
+      if (auth2.state?.baseUrl) {
+        this.baseUrl = auth2.state.baseUrl;
+      }
+    }
+    const baseFetch = fetchUrl ?? `${this.apiBaseUrl}/auth/signout`;
+    const fetchOptions = {
+      method: "post",
+      body: new URLSearchParams({
+        csrfToken: String(await this.getCsrfToken()),
+        callbackUrl,
+        json: String(true)
+      })
+    };
+    const res = await this.fetchFormData(
+      baseFetch,
+      fetchOptions
+    );
+    broadcast.post({ event: "session", data: { trigger: "signout" } });
+    if (this.requestInit?.credentials) {
+      window.location.href = callbackUrl;
+      if (callbackUrl.includes("#")) window.location.reload();
+      return void 0;
+    }
+    if (options?.redirect ?? true) {
+      const url = res?.data?.url ?? callbackUrl;
+      window.location.href = url;
+      if (url.includes("#")) window.location.reload();
+      return void 0;
+    }
+    await this.state.getSession({ event: "storage" });
+    return res?.data;
+  }
+  async signIn(provider, options, authorizationParams) {
+    const {
+      callbackUrl = window.location.href,
+      resetUrl = window.location.href,
+      providersUrl,
+      csrfUrl,
+      baseUrl,
+      fetchUrl,
+      init,
+      auth: auth2,
+      redirect = true,
+      ...remaining
+    } = options ?? {};
+    if (baseUrl) {
+      this.baseUrl = baseUrl;
+    }
+    if (auth2) {
+      if (auth2.requestInit) {
+        this.requestInit = auth2.requestInit;
+      }
+      if (auth2.state?.baseUrl) {
+        this.baseUrl = auth2.state.baseUrl;
+      }
+    }
+    if (init) {
+      this.requestInit = init;
+    }
+    const providers = await this.getProviders(providersUrl);
+    if (!providers) {
+      return { error: "No providers enabled" };
+    }
+    if (!provider || !(provider in providers)) {
+      return { error: `Provider ${provider} not enabled` };
+    }
+    const isCredentials = providers[provider].type === "credentials";
+    const isEmail = providers[provider].type === "email";
+    const isSupportingReturn = isCredentials || isEmail;
+    const baseFetch = `${this.apiBaseUrl}/auth`;
+    const signInUrl = fetchUrl ?? `${baseFetch}/${isCredentials ? "callback" : "signin"}/${provider}`;
+    const _signInUrl = `${signInUrl}${authorizationParams ? `?${new URLSearchParams(authorizationParams)}` : ""}`;
+    const data = await this.fetchFormData(_signInUrl, {
+      method: "post",
+      body: new URLSearchParams({
+        ...remaining,
+        csrfToken: String(await this.getCsrfToken(csrfUrl)),
+        callbackUrl,
+        json: String(true),
+        resetUrl
+      })
+    });
+    if (data?.ok && this.requestInit?.credentials && isSupportingReturn) {
+      window.location.reload();
+      return;
+    }
+    if (data?.ok && (redirect || !isSupportingReturn)) {
+      const url = data?.data.url ?? callbackUrl;
+      window.location.href = url;
+      if (url.includes("#")) window.location.reload();
+      return;
+    }
+    const error = data?.data?.url ? new URL(String(data?.data?.url)).searchParams.get("error") : null;
+    if (data?.ok) {
+      await this.initialize();
+      await this.getSession({ event: "storage" });
+    }
+    return {
+      error,
+      status: data?.status,
+      ok: data?.ok,
+      url: error ? null : data?.url
+    };
+  }
+  async signUp(options) {
+    const {
+      password,
+      tenantId,
+      fetchUrl,
+      newTenantName,
+      createTenant,
+      baseUrl,
+      init,
+      email,
+      auth: auth2,
+      callbackUrl = window.location.href
+    } = options;
+    if (baseUrl) {
+      this.baseUrl = baseUrl;
+    }
+    if (auth2) {
+      if (auth2.requestInit) {
+        this.requestInit = auth2.requestInit;
+      }
+      if (auth2.state?.baseUrl) {
+        this.baseUrl = auth2.state.baseUrl;
+      }
+    }
+    if (init) {
+      this.requestInit = init;
+    }
+    const searchParams = new URLSearchParams();
+    if (newTenantName) {
+      searchParams.set("newTenantName", newTenantName);
+    } else if (createTenant) {
+      if (typeof createTenant === "boolean") {
+        searchParams.set("newTenantName", email);
+      } else if (typeof createTenant === "string") {
+        searchParams.set("newTenantName", createTenant);
+      }
+    }
+    if (tenantId) {
+      searchParams.set("tenantId", tenantId);
+    }
+    let signUpUrl = fetchUrl ?? `${this.apiBaseUrl}/signup`;
+    if (searchParams.size > 0) {
+      signUpUrl += `?${searchParams}`;
+    }
+    const data = await this.fetchData(signUpUrl, {
+      method: "post",
+      body: JSON.stringify({ email, password })
+    });
+    const error = data?.url ? new URL(data.url).searchParams.get("error") : null;
+    if (!error) {
+      if (data) {
+        await this.initialize({ event: "storage" });
+        await this.getSession({ event: "storage" });
+      }
+      if (this.requestInit?.credentials) {
+        window.location.reload();
+        return;
+      }
+      if (options?.redirect ?? true) {
+        const url = callbackUrl;
+        window.location.href = url;
+        if (url.includes("#")) window.location.reload();
+      }
+    }
+    return {
+      data,
+      error
+    };
+  }
+  async resetPassword(options) {
+    const { password, fetchUrl, email, redirect, callbackUrl } = options;
+    this._configureFetch(options);
+    const resetPasswordUrl = fetchUrl ?? `${this.apiBaseUrl}/auth/reset-password`;
+    let resetPasswordWithParams = resetPasswordUrl;
+    const searchParams = new URLSearchParams();
+    if (redirect === false) {
+      searchParams.set("json", "true");
+    }
+    if (searchParams.size > 0) {
+      resetPasswordWithParams += `?${searchParams}`;
+    }
+    const data = await this.fetchData(resetPasswordWithParams, {
+      method: "post",
+      body: JSON.stringify({
+        email,
+        password,
+        redirectUrl: resetPasswordUrl,
+        callbackUrl
+      })
+    });
+    if (redirect === false) {
+      const { url: urlWithParams } = data;
+      resetPasswordWithParams = `${urlWithParams}&redirect=false`;
+      await this.sendData(resetPasswordWithParams);
+    }
+    return await this.sendData(resetPasswordWithParams, {
+      method: password ? "put" : "post",
+      body: JSON.stringify({ email, password })
+    });
+  }
+  _configureFetch(params) {
+    const { baseUrl, init, auth: auth2 } = params;
+    if (baseUrl) {
+      this.baseUrl = baseUrl;
+    }
+    if (auth2) {
+      if (auth2.requestInit) {
+        this.requestInit = auth2.requestInit;
+      }
+      if (auth2.state?.baseUrl) {
+        this.baseUrl = auth2.state.baseUrl;
+      }
+    }
+    if (init) {
+      this.requestInit = init;
+    }
+  }
+};
+function parseUrl(url) {
+  let defaultUrl = new URL("http://localhost:3000");
+  if (typeof window !== "undefined") {
+    defaultUrl = new URL(`${window.location.origin}/api`);
+  }
+  if (url && !url.startsWith("http")) {
+    url = `https://${url}`;
+  }
+  const _url = new URL(url ?? defaultUrl);
+  const path = (_url.pathname === "/" ? defaultUrl.pathname : _url.pathname).replace(/\/$/, "");
+  const base = `${_url.origin}${path}`;
+  return {
+    origin: _url.origin,
+    host: _url.host,
+    path,
+    base,
+    toString: () => base
+  };
+}
+var authorizer = new Authorizer();
+var _auth = () => {
+  return authorizer;
+};
+var auth = _auth();
+var getSession = async function getSession2(params) {
+  return await auth.getSession(params);
+};
+var getCsrfToken = async function getCsrfToken2(url) {
+  return auth.getCsrfToken(url);
+};
+var getProviders = async function getProviders2() {
+  return auth.getProviders();
+};
+var signOut = async function signOut2(options) {
+  return auth.signOut(options);
+};
+var signIn = async function signOut3(provider, options, authParams) {
+  return auth.signIn(provider, options, authParams);
+};
+var signUp = async function signUp2(options) {
+  return auth.signUp(options);
+};
+var resetPassword = async function resetPassword2(options) {
+  return auth.resetPassword(options);
+};
+
+// src/status.ts
+function getStatus(load, sess) {
+  if (load) {
+    return "loading";
+  }
+  if (sess) {
+    return "authenticated";
+  }
+  return "unauthenticated";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Authorizer,
+  auth,
+  broadcast,
+  getCsrfToken,
+  getProviders,
+  getSession,
+  getStatus,
+  resetPassword,
+  signIn,
+  signOut,
+  signUp
+});
+//# sourceMappingURL=index.js.map