@nvwa-app/sdk-core 0.4.0

package/dist/index.mjs

@@ -0,0 +1,705 @@
+import { createAuthClient } from 'better-auth/client';
+import { usernameClient } from 'better-auth/client/plugins';
+import { PostgrestClient, FetchResponse as FetchResponse$1 } from '@nvwa-app/postgrest-js';
+
+var __defProp$7 = Object.defineProperty;
+var __defNormalProp$7 = (obj, key, value) => key in obj ? __defProp$7(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$7 = (obj, key, value) => __defNormalProp$7(obj, typeof key !== "symbol" ? key + "" : key, value);
+const AUTH_BASE_PATH = "/auth";
+const LOGIN_TOKEN_KEY = "nvwa_login_token";
+const LOGIN_USER_PROFILE_KEY = "nvwa_user_profile";
+class NvwaAuthClient {
+  constructor(baseUrl, fetch, storage) {
+    __publicField$7(this, "storage");
+    __publicField$7(this, "authClient");
+    this.storage = storage;
+    this.authClient = createAuthClient({
+      baseUrl,
+      fetchOptions: {
+        // @ts-ignore
+        customFetchImpl: fetch,
+        auth: {
+          type: "Bearer",
+          token: () => storage.get(LOGIN_TOKEN_KEY)
+        },
+        onSuccess: (ctx) => {
+          const authToken = ctx.response.headers.get(
+            "set-auth-token"
+          );
+          if (authToken) {
+            storage.set(LOGIN_TOKEN_KEY, authToken);
+          }
+        }
+      },
+      plugins: [
+        usernameClient()
+      ]
+    });
+  }
+  async signInWithUsername(username, password) {
+    const result = await this.authClient.signIn.username({
+      username,
+      password
+    });
+    this.saveSession(result);
+  }
+  saveSession(result) {
+    var _a, _b;
+    if (result.error) {
+      throw new Error(result.error.message);
+    }
+    this.storage.set(LOGIN_TOKEN_KEY, (_a = result.data) == null ? void 0 : _a.token);
+    this.storage.set(LOGIN_USER_PROFILE_KEY, (_b = result.data) == null ? void 0 : _b.user);
+  }
+  async signOut() {
+    await this.storage.remove(LOGIN_TOKEN_KEY);
+    await this.storage.remove(LOGIN_USER_PROFILE_KEY);
+  }
+  async updateUserPassword(oldPassword, newPassword, revokeOtherSessions = false) {
+    const result = await this.authClient.changePassword({
+      currentPassword: oldPassword,
+      newPassword,
+      revokeOtherSessions
+    });
+    this.saveSession(result);
+  }
+}
+
+var __defProp$6 = Object.defineProperty;
+var __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$6 = (obj, key, value) => __defNormalProp$6(obj, key + "" , value);
+class NvwaEdgeFunctions {
+  constructor(http) {
+    __publicField$6(this, "http");
+    this.http = http;
+  }
+  async invoke(name, options) {
+    const response = await this.http.request(
+      "/functions/" + name,
+      {
+        method: options.method || "POST",
+        data: options.body,
+        headers: options.headers
+      }
+    );
+    return response.body;
+  }
+}
+
+var __defProp$5 = Object.defineProperty;
+var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$5 = (obj, key, value) => __defNormalProp$5(obj, typeof key !== "symbol" ? key + "" : key, value);
+class FetchResponse {
+  constructor(ok, status, statusText, headers, body) {
+    __publicField$5(this, "ok");
+    __publicField$5(this, "status");
+    __publicField$5(this, "statusText");
+    __publicField$5(this, "headers");
+    __publicField$5(this, "body");
+    this.ok = ok;
+    this.status = status;
+    this.statusText = statusText;
+    this.headers = headers;
+    this.body = body;
+  }
+  async text() {
+    if (typeof this.body === "string") {
+      return this.body;
+    }
+    return JSON.stringify(this.body);
+  }
+  async json() {
+    if (typeof this.body === "string") {
+      try {
+        return JSON.parse(this.body);
+      } catch {
+        return this.body;
+      }
+    }
+    return this.body;
+  }
+  async arrayBuffer() {
+    if (this.body instanceof ArrayBuffer) {
+      return this.body;
+    }
+    if (typeof this.body === "string") {
+      const encoder = new TextEncoder();
+      return encoder.encode(this.body).buffer;
+    }
+    throw new Error("Cannot convert body to ArrayBuffer");
+  }
+  async blob() {
+    if (this.body instanceof Blob) {
+      return this.body;
+    }
+    if (typeof this.body === "string") {
+      return new Blob([this.body], { type: this.headers["content-type"] || "text/plain" });
+    }
+    throw new Error("Cannot convert body to Blob");
+  }
+}
+class NvwaHttpClient {
+  // 便捷方法：发送 JSON 请求
+  async jsonRequest(url, request) {
+    const jsonRequest = {
+      ...request,
+      headers: {
+        "Content-Type": "application/json",
+        ...request.headers
+      },
+      data: typeof request.data === "object" ? JSON.stringify(request.data) : request.data
+    };
+    return this.request(url, jsonRequest);
+  }
+  // 便捷方法：发送带认证的 JSON 请求
+  async jsonRequestWithAuth(url, request, handleUnauthorized) {
+    const jsonRequest = {
+      ...request,
+      headers: {
+        "Content-Type": "application/json",
+        ...request.headers
+      },
+      data: typeof request.data === "object" ? JSON.stringify(request.data) : request.data
+    };
+    return this.requestWithAuth(url, jsonRequest, handleUnauthorized);
+  }
+}
+
+var __defProp$4 = Object.defineProperty;
+var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$4 = (obj, key, value) => __defNormalProp$4(obj, typeof key !== "symbol" ? key + "" : key, value);
+const FILE_STORAGE_BASE_PATH = "/storage";
+const GENERATE_UPLOAD_URL_PATH = FILE_STORAGE_BASE_PATH + "/generateUploadUrl";
+class NvwaFileStorage {
+  constructor(baseUrl, http) {
+    __publicField$4(this, "baseUrl");
+    __publicField$4(this, "http");
+    this.baseUrl = baseUrl;
+    this.http = http;
+  }
+  async uploadFile(file) {
+    const uploadUrlResponse = await this.http.request(
+      this.baseUrl + GENERATE_UPLOAD_URL_PATH,
+      {
+        method: "POST",
+        data: {
+          fileName: file.name || file.fileName,
+          fileSize: file.size || file.fileSize,
+          fileType: file.type || file.fileType
+        }
+      }
+    );
+    const { url: uploadUrl } = uploadUrlResponse.body;
+    if (!uploadUrl) {
+      throw new Error("\u83B7\u53D6\u4E0A\u4F20URL\u5931\u8D25");
+    }
+    const uploadResult = await this.http.request(
+      uploadUrl,
+      {
+        method: "PUT",
+        data: file,
+        headers: {
+          "Content-Type": file.type || file.fileType || "application/octet-stream"
+        }
+      }
+    );
+    const fileUrl = uploadResult.body.url.split("?")[0];
+    return { url: fileUrl };
+  }
+}
+
+const ENTITIES_BASE_PATH = "/entities";
+const buildPostgrestFetch = (httpClient, handleUnauthorized) => {
+  const customFetch = async (input, init) => {
+    console.log("customFetch", input, init);
+    let url;
+    if (typeof input === "string") {
+      url = input;
+    } else if (input && typeof input === "object") {
+      if (typeof input.toString === "function" && !input.url) {
+        url = input.toString();
+      } else if (input.url) {
+        url = input.url;
+        if (!init) {
+          init = {};
+        }
+        init.method = input.method;
+        init.headers = input.headers;
+        init.body = input.body;
+      } else {
+        throw new Error("Unsupported input type for fetch");
+      }
+    } else {
+      throw new Error("Unsupported input type for fetch");
+    }
+    const method = ((init == null ? void 0 : init.method) || "GET").toUpperCase();
+    const headers = {};
+    if (init == null ? void 0 : init.headers) {
+      if (init.headers && typeof init.headers.forEach === "function") {
+        init.headers.forEach((v, k) => {
+          headers[k] = v;
+        });
+      } else if (Array.isArray(init.headers)) {
+        for (const [k, v] of init.headers) headers[k] = v;
+      } else {
+        Object.assign(headers, init.headers);
+      }
+    }
+    let body = init == null ? void 0 : init.body;
+    let response;
+    try {
+      response = await httpClient.requestWithAuth(url, {
+        method,
+        data: body,
+        headers
+      }, handleUnauthorized);
+    } catch (e) {
+      return new FetchResponse$1((e == null ? void 0 : e.message) || "Internal Error", {
+        status: 500,
+        statusText: "Internal Error"
+      });
+    }
+    let responseBody = response.body;
+    let responseData = null;
+    const contentType = response.headers["content-type"] || response.headers["Content-Type"] || "";
+    if (contentType.startsWith("application/json") && typeof responseBody !== "string") {
+      responseData = JSON.stringify(responseBody);
+    } else if (typeof responseBody === "string") {
+      responseData = responseBody;
+    } else if (responseBody && (responseBody.constructor === Blob || responseBody.constructor === ArrayBuffer || typeof responseBody.getReader === "function")) {
+      responseData = responseBody;
+    } else {
+      responseData = JSON.stringify(responseBody);
+    }
+    return new FetchResponse$1(responseData, {
+      status: response.status,
+      headers: response.headers
+    });
+  };
+  return customFetch;
+};
+const createPostgrestClient = (baseUrl, httpClient, handleUnauthorized) => {
+  return new PostgrestClient(baseUrl + ENTITIES_BASE_PATH, {
+    fetch: buildPostgrestFetch(httpClient, handleUnauthorized)
+  });
+};
+
+var __defProp$3 = Object.defineProperty;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$3 = (obj, key, value) => __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value);
+class Headers {
+  constructor(init) {
+    __publicField$3(this, "headerMap", /* @__PURE__ */ new Map());
+    if (!init) return;
+    if (init instanceof Headers) {
+      init.forEach((v, k) => this.set(k, v));
+    } else if (Array.isArray(init)) {
+      for (const [k, v] of init) this.set(k, String(v));
+    } else if (typeof init === "object") {
+      for (const k of Object.keys(init)) this.set(k, String(init[k]));
+    }
+  }
+  append(name, value) {
+    const key = name.toLowerCase();
+    const existing = this.headerMap.get(key);
+    this.headerMap.set(key, existing ? `${existing}, ${value}` : value);
+  }
+  set(name, value) {
+    this.headerMap.set(name.toLowerCase(), String(value));
+  }
+  get(name) {
+    const v = this.headerMap.get(name.toLowerCase());
+    return v == null ? null : v;
+  }
+  has(name) {
+    return this.headerMap.has(name.toLowerCase());
+  }
+  delete(name) {
+    this.headerMap.delete(name.toLowerCase());
+  }
+  forEach(callback) {
+    for (const [k, v] of this.headerMap.entries()) callback(v, k, this);
+  }
+  entries() {
+    return this.headerMap.entries();
+  }
+  keys() {
+    return this.headerMap.keys();
+  }
+  values() {
+    return this.headerMap.values();
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+}
+class URLSearchParams {
+  constructor(init) {
+    __publicField$3(this, "params", /* @__PURE__ */ new Map());
+    if (init) {
+      if (typeof init === "string") {
+        this.parseString(init);
+      } else if (init instanceof URLSearchParams) {
+        this.params = new Map(init.params);
+      } else if (Array.isArray(init)) {
+        for (const [key, value] of init) {
+          this.append(key, value);
+        }
+      } else if (init && typeof init === "object") {
+        for (const [key, value] of Object.entries(init)) {
+          this.set(key, value);
+        }
+      }
+    }
+  }
+  parseString(search) {
+    if (search.startsWith("?")) {
+      search = search.slice(1);
+    }
+    const pairs = search.split("&");
+    for (const pair of pairs) {
+      if (pair) {
+        const [key, value] = pair.split("=");
+        if (key) {
+          this.append(
+            decodeURIComponent(key),
+            value ? decodeURIComponent(value) : ""
+          );
+        }
+      }
+    }
+  }
+  append(name, value) {
+    const existing = this.params.get(name) || [];
+    existing.push(value);
+    this.params.set(name, existing);
+  }
+  delete(name) {
+    this.params.delete(name);
+  }
+  get(name) {
+    const values = this.params.get(name);
+    return values ? values[0] : null;
+  }
+  getAll(name) {
+    return this.params.get(name) || [];
+  }
+  has(name) {
+    return this.params.has(name);
+  }
+  set(name, value) {
+    this.params.set(name, [value]);
+  }
+  sort() {
+    const sortedEntries = Array.from(this.params.entries()).sort(([a], [b]) => a.localeCompare(b));
+    this.params = new Map(sortedEntries);
+  }
+  toString() {
+    const pairs = [];
+    for (const [name, values] of this.params.entries()) {
+      for (const value of values) {
+        pairs.push(
+          `${encodeURIComponent(name)}=${encodeURIComponent(value)}`
+        );
+      }
+    }
+    return pairs.join("&");
+  }
+  forEach(callback) {
+    for (const [name, values] of this.params.entries()) {
+      for (const value of values) {
+        callback(value, name, this);
+      }
+    }
+  }
+  keys() {
+    return this.params.keys();
+  }
+  values() {
+    const allValues = [];
+    for (const values of this.params.values()) {
+      allValues.push(...values);
+    }
+    return allValues[Symbol.iterator]();
+  }
+  entries() {
+    const allEntries = [];
+    for (const [name, values] of this.params.entries()) {
+      for (const value of values) {
+        allEntries.push([name, value]);
+      }
+    }
+    return allEntries[Symbol.iterator]();
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  get size() {
+    return this.params.size;
+  }
+}
+class URL {
+  constructor(url, base) {
+    __publicField$3(this, "href");
+    __publicField$3(this, "origin");
+    __publicField$3(this, "protocol");
+    __publicField$3(this, "username");
+    __publicField$3(this, "password");
+    __publicField$3(this, "host");
+    __publicField$3(this, "hostname");
+    __publicField$3(this, "port");
+    __publicField$3(this, "pathname");
+    __publicField$3(this, "search");
+    __publicField$3(this, "searchParams");
+    __publicField$3(this, "hash");
+    let urlString;
+    if (url instanceof URL) {
+      urlString = url.href;
+    } else if (base) {
+      const baseUrl = base instanceof URL ? base.href : base;
+      urlString = this.resolve(baseUrl, url);
+    } else {
+      urlString = url;
+    }
+    const parsed = this.parseUrl(urlString);
+    this.href = urlString;
+    this.origin = `${parsed.protocol}//${parsed.host}`;
+    this.protocol = parsed.protocol;
+    this.username = parsed.username;
+    this.password = parsed.password;
+    this.host = parsed.host;
+    this.hostname = parsed.hostname;
+    this.port = parsed.port;
+    this.pathname = parsed.pathname;
+    this.search = parsed.search;
+    this.searchParams = new URLSearchParams(parsed.search);
+    this.hash = parsed.hash;
+  }
+  resolve(base, relative) {
+    if (relative.startsWith("http://") || relative.startsWith("https://")) {
+      return relative;
+    }
+    if (relative.startsWith("//")) {
+      const baseParsed2 = this.parseUrl(base);
+      return `${baseParsed2.protocol}${relative}`;
+    }
+    if (relative.startsWith("/")) {
+      const baseParsed2 = this.parseUrl(base);
+      return `${baseParsed2.protocol}//${baseParsed2.host}${relative}`;
+    }
+    const baseParsed = this.parseUrl(base);
+    const basePath = baseParsed.pathname.endsWith("/") ? baseParsed.pathname : baseParsed.pathname + "/";
+    return `${baseParsed.protocol}//${baseParsed.host}${basePath}${relative}`;
+  }
+  parseUrl(url) {
+    const urlMatch = url.match(
+      /^(([^:\/?#]+):)?(\/\/([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?$/
+    );
+    if (!urlMatch) {
+      throw new TypeError("Invalid URL");
+    }
+    const protocol = urlMatch[2] || "";
+    const authority = urlMatch[4] || "";
+    const pathname = urlMatch[5] || "/";
+    const search = urlMatch[7] ? `?${urlMatch[7]}` : "";
+    const hash = urlMatch[9] ? `#${urlMatch[9]}` : "";
+    if (!protocol && !authority && !pathname.startsWith("/")) {
+      if (!pathname.includes("/") && !pathname.includes(".")) {
+        throw new TypeError("Invalid URL");
+      }
+    }
+    const authMatch = authority.match(/^([^@]*)@(.+)$/);
+    let username = "";
+    let password = "";
+    let host = authority;
+    if (authMatch) {
+      const userInfo = authMatch[1];
+      host = authMatch[2];
+      const userMatch = userInfo.match(/^([^:]*):?(.*)$/);
+      if (userMatch) {
+        username = userMatch[1] || "";
+        password = userMatch[2] || "";
+      }
+    }
+    const hostMatch = host.match(/^([^:]+):?(\d*)$/);
+    const hostname = hostMatch ? hostMatch[1] : host;
+    const port = hostMatch && hostMatch[2] ? hostMatch[2] : "";
+    return {
+      protocol: protocol ? `${protocol}:` : "",
+      username,
+      password,
+      host,
+      hostname,
+      port,
+      pathname,
+      search,
+      hash
+    };
+  }
+  toString() {
+    const searchString = this.searchParams.toString();
+    const search = searchString ? `?${searchString}` : "";
+    return `${this.protocol}//${this.host}${this.pathname}${search}${this.hash}`;
+  }
+  toJSON() {
+    return this.toString();
+  }
+}
+
+var __defProp$2 = Object.defineProperty;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$2 = (obj, key, value) => __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
+class Request {
+  constructor(input, init) {
+    __publicField$2(this, "url");
+    __publicField$2(this, "method");
+    __publicField$2(this, "headers");
+    __publicField$2(this, "body");
+    __publicField$2(this, "timeout");
+    __publicField$2(this, "signal");
+    if (typeof input === "string") {
+      this.url = input;
+    } else if (input == null ? void 0 : input.url) {
+      this.url = String(input.url);
+    } else if (typeof (input == null ? void 0 : input.toString) === "function") {
+      this.url = String(input.toString());
+    } else {
+      throw new Error("Invalid input for Request");
+    }
+    this.method = ((init == null ? void 0 : init.method) || "GET").toUpperCase();
+    this.headers = (init == null ? void 0 : init.headers) instanceof Headers ? init.headers : new Headers(init == null ? void 0 : init.headers);
+    this.body = init == null ? void 0 : init.body;
+    this.timeout = init == null ? void 0 : init.timeout;
+    this.signal = (init == null ? void 0 : init.signal) || void 0;
+  }
+  clone() {
+    return new Request(this.url, {
+      method: this.method,
+      headers: this.headers,
+      body: this.body,
+      timeout: this.timeout
+    });
+  }
+  toString() {
+    return this.url;
+  }
+}
+
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+class Response {
+  constructor(body, init) {
+    __publicField$1(this, "bodyData");
+    __publicField$1(this, "status");
+    __publicField$1(this, "statusText");
+    __publicField$1(this, "headers");
+    __publicField$1(this, "ok");
+    var _a, _b;
+    this.bodyData = body;
+    this.status = (_a = init == null ? void 0 : init.status) != null ? _a : 200;
+    this.statusText = (_b = init == null ? void 0 : init.statusText) != null ? _b : "";
+    this.headers = normalizeHeaders(init == null ? void 0 : init.headers);
+    this.ok = this.status >= 200 && this.status < 300;
+  }
+  async text() {
+    if (typeof this.bodyData === "string") return this.bodyData;
+    if (this.bodyData == null) return "";
+    if (typeof this.bodyData === "object") return JSON.stringify(this.bodyData);
+    return String(this.bodyData);
+  }
+  async json() {
+    if (typeof this.bodyData === "string") {
+      try {
+        return JSON.parse(this.bodyData);
+      } catch {
+      }
+    }
+    return this.bodyData;
+  }
+  async arrayBuffer() {
+    const text = await this.text();
+    const encoder = new TextEncoder();
+    return encoder.encode(text).buffer;
+  }
+}
+function normalizeHeaders(h) {
+  if (!h) return new Headers();
+  return new Headers(h);
+}
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+class AbortSignal {
+  constructor() {
+    __publicField(this, "_aborted", false);
+    __publicField(this, "listeners", /* @__PURE__ */ new Set());
+    __publicField(this, "onabort", null);
+  }
+  get aborted() {
+    return this._aborted;
+  }
+  // 供控制器触发
+  _trigger() {
+    if (this._aborted) return;
+    this._aborted = true;
+    if (typeof this.onabort === "function") {
+      try {
+        this.onabort();
+      } catch {
+      }
+    }
+    for (const l of Array.from(this.listeners)) {
+      try {
+        l();
+      } catch {
+      }
+    }
+    this.listeners.clear();
+  }
+  addEventListener(_, listener) {
+    if (this._aborted) {
+      try {
+        listener();
+      } catch {
+      }
+      return;
+    }
+    this.listeners.add(listener);
+  }
+  removeEventListener(_, listener) {
+    this.listeners.delete(listener);
+  }
+  toString() {
+    return "[object AbortSignal]";
+  }
+}
+class AbortController {
+  constructor() {
+    __publicField(this, "_signal");
+    this._signal = new AbortSignal();
+  }
+  get signal() {
+    return this._signal;
+  }
+  abort() {
+    this._signal._trigger();
+  }
+  toString() {
+    return "[object AbortController]";
+  }
+}
+
+function polyfill(_global) {
+  _global.URL = URL;
+  _global.URLSearchParams = URLSearchParams;
+  _global.Headers = Headers;
+  _global.Request = Request;
+  _global.Response = Response;
+  _global.AbortController = AbortController;
+  _global.AbortSignal = AbortSignal;
+}
+
+export { AUTH_BASE_PATH, AbortController, AbortSignal, ENTITIES_BASE_PATH, FILE_STORAGE_BASE_PATH, FetchResponse, GENERATE_UPLOAD_URL_PATH, Headers, LOGIN_TOKEN_KEY, LOGIN_USER_PROFILE_KEY, NvwaAuthClient, NvwaEdgeFunctions, NvwaFileStorage, NvwaHttpClient, Request, Response, URL, URLSearchParams, createPostgrestClient, polyfill };
+//# sourceMappingURL=index.mjs.map