get-db9 0.1.0

package/dist/index.cjs

@@ -0,0 +1,624 @@
+"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);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Db9AuthError: () => Db9AuthError,
+  Db9ConflictError: () => Db9ConflictError,
+  Db9Error: () => Db9Error,
+  Db9NotFoundError: () => Db9NotFoundError,
+  FileCredentialStore: () => FileCredentialStore,
+  MemoryCredentialStore: () => MemoryCredentialStore,
+  createAdminClient: () => createAdminClient,
+  createCustomerClient: () => createCustomerClient,
+  defaultCredentialStore: () => defaultCredentialStore,
+  instantDatabase: () => instantDatabase
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var Db9Error = class _Db9Error extends Error {
+  statusCode;
+  response;
+  constructor(message, statusCode, response) {
+    super(message);
+    this.name = "Db9Error";
+    this.statusCode = statusCode;
+    this.response = response;
+  }
+  static async fromResponse(response) {
+    let message;
+    try {
+      const body = await response.json();
+      message = body.message || response.statusText;
+    } catch {
+      message = response.statusText;
+    }
+    switch (response.status) {
+      case 401:
+        return new Db9AuthError(message, response);
+      case 404:
+        return new Db9NotFoundError(message, response);
+      case 409:
+        return new Db9ConflictError(message, response);
+      default:
+        return new _Db9Error(message, response.status, response);
+    }
+  }
+};
+var Db9AuthError = class extends Db9Error {
+  constructor(message, response) {
+    super(message, 401, response);
+    this.name = "Db9AuthError";
+  }
+};
+var Db9NotFoundError = class extends Db9Error {
+  constructor(message, response) {
+    super(message, 404, response);
+    this.name = "Db9NotFoundError";
+  }
+};
+var Db9ConflictError = class extends Db9Error {
+  constructor(message, response) {
+    super(message, 409, response);
+    this.name = "Db9ConflictError";
+  }
+};
+
+// src/http.ts
+function createHttpClient(options) {
+  const fetchFn = options.fetch ?? globalThis.fetch;
+  const baseUrl = options.baseUrl.replace(/\/$/, "");
+  async function request(method, path, body, params) {
+    let url = `${baseUrl}${path}`;
+    if (params) {
+      const searchParams = new URLSearchParams();
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0) {
+          searchParams.set(key, value);
+        }
+      }
+      const qs = searchParams.toString();
+      if (qs) url += `?${qs}`;
+    }
+    const headers = {
+      "Content-Type": "application/json",
+      ...options.headers
+    };
+    const init = { method, headers };
+    if (body !== void 0) {
+      init.body = JSON.stringify(body);
+    }
+    const response = await fetchFn(url, init);
+    if (!response.ok) {
+      throw await Db9Error.fromResponse(response);
+    }
+    if (response.status === 204) {
+      return void 0;
+    }
+    return response.json();
+  }
+  return {
+    get: (path, params) => request("GET", path, void 0, params),
+    post: (path, body) => request("POST", path, body),
+    put: (path, body) => request("PUT", path, body),
+    del: (path) => request("DELETE", path)
+  };
+}
+
+// src/customer.ts
+function createCustomerClient(options = {}) {
+  const baseUrl = options.baseUrl ?? "https://db9.shared.aws.tidbcloud.com/api";
+  let token = options.token;
+  let tokenLoaded = !!token;
+  const publicClient = createHttpClient({
+    baseUrl,
+    fetch: options.fetch
+  });
+  async function getAuthClient() {
+    if (!token && !tokenLoaded && options.credentialStore) {
+      const creds = await options.credentialStore.load();
+      if (creds) token = creds.token;
+      tokenLoaded = true;
+    }
+    if (!token) throw new Error("No authentication token available");
+    return createHttpClient({
+      baseUrl,
+      fetch: options.fetch,
+      headers: { Authorization: `Bearer ${token}` }
+    });
+  }
+  return {
+    auth: {
+      // Public endpoints (no token required)
+      register: (req) => publicClient.post("/customer/register", req),
+      login: (req) => publicClient.post("/customer/login", req),
+      anonymousRegister: () => publicClient.post(
+        "/customer/anonymous-register"
+      ),
+      anonymousRefresh: (req) => publicClient.post(
+        "/customer/anonymous-refresh",
+        req
+      ),
+      // Authenticated endpoints
+      me: async () => {
+        const client = await getAuthClient();
+        return client.get("/customer/me");
+      },
+      getAnonymousSecret: async () => {
+        const client = await getAuthClient();
+        return client.get(
+          "/customer/anonymous-secret"
+        );
+      },
+      claim: async (req) => {
+        const client = await getAuthClient();
+        return client.post("/customer/claim", req);
+      }
+    },
+    tokens: {
+      list: async () => {
+        const client = await getAuthClient();
+        return client.get("/customer/tokens");
+      },
+      revoke: async (tokenId) => {
+        const client = await getAuthClient();
+        return client.del(`/customer/tokens/${tokenId}`);
+      }
+    },
+    databases: {
+      // ── CRUD ──────────────────────────────────────────────────
+      create: async (req) => {
+        const client = await getAuthClient();
+        return client.post("/customer/databases", req);
+      },
+      list: async () => {
+        const client = await getAuthClient();
+        return client.get("/customer/databases");
+      },
+      get: async (databaseId) => {
+        const client = await getAuthClient();
+        return client.get(
+          `/customer/databases/${databaseId}`
+        );
+      },
+      delete: async (databaseId) => {
+        const client = await getAuthClient();
+        return client.del(
+          `/customer/databases/${databaseId}`
+        );
+      },
+      resetPassword: async (databaseId) => {
+        const client = await getAuthClient();
+        return client.post(
+          `/customer/databases/${databaseId}/reset-password`
+        );
+      },
+      observability: async (databaseId) => {
+        const client = await getAuthClient();
+        return client.get(
+          `/customer/databases/${databaseId}/observability`
+        );
+      },
+      // ── SQL Execution ─────────────────────────────────────────
+      sql: async (databaseId, query) => {
+        const client = await getAuthClient();
+        return client.post(
+          `/customer/databases/${databaseId}/sql`,
+          { query }
+        );
+      },
+      sqlFile: async (databaseId, fileContent) => {
+        const client = await getAuthClient();
+        return client.post(
+          `/customer/databases/${databaseId}/sql`,
+          { file_content: fileContent }
+        );
+      },
+      // ── Schema & Dump ─────────────────────────────────────────
+      schema: async (databaseId) => {
+        const client = await getAuthClient();
+        return client.get(
+          `/customer/databases/${databaseId}/schema`
+        );
+      },
+      dump: async (databaseId, req) => {
+        const client = await getAuthClient();
+        return client.post(
+          `/customer/databases/${databaseId}/dump`,
+          req
+        );
+      },
+      // ── Migrations ────────────────────────────────────────────
+      applyMigration: async (databaseId, req) => {
+        const client = await getAuthClient();
+        return client.post(
+          `/customer/databases/${databaseId}/migrations`,
+          req
+        );
+      },
+      listMigrations: async (databaseId) => {
+        const client = await getAuthClient();
+        return client.get(
+          `/customer/databases/${databaseId}/migrations`
+        );
+      },
+      // ── Branching ─────────────────────────────────────────────
+      branch: async (databaseId, req) => {
+        const client = await getAuthClient();
+        return client.post(
+          `/customer/databases/${databaseId}/branch`,
+          req
+        );
+      },
+      // ── User Management ───────────────────────────────────────
+      users: {
+        list: async (databaseId) => {
+          const client = await getAuthClient();
+          return client.get(
+            `/customer/databases/${databaseId}/users`
+          );
+        },
+        create: async (databaseId, req) => {
+          const client = await getAuthClient();
+          return client.post(
+            `/customer/databases/${databaseId}/users`,
+            req
+          );
+        },
+        delete: async (databaseId, username) => {
+          const client = await getAuthClient();
+          return client.del(
+            `/customer/databases/${databaseId}/users/${username}`
+          );
+        }
+      }
+    }
+  };
+}
+
+// src/credentials.ts
+var import_toml = require("@iarna/toml");
+var FileCredentialStore = class {
+  customPath;
+  /**
+   * @param path — Override the credential file location.
+   *               Defaults to `~/.db9/credentials` (resolved lazily).
+   */
+  constructor(path) {
+    this.customPath = path;
+  }
+  /** Resolve the credential file path (lazy to avoid top-level `os` import). */
+  async resolvePath() {
+    if (this.customPath) return this.customPath;
+    const os = await import("os");
+    const nodePath = await import("path");
+    return nodePath.join(os.homedir(), ".db9", "credentials");
+  }
+  async load() {
+    const fs = await import("fs/promises");
+    const filePath = await this.resolvePath();
+    let content;
+    try {
+      content = await fs.readFile(filePath, "utf-8");
+    } catch (err) {
+      if (err.code === "ENOENT") return null;
+      throw err;
+    }
+    const parsed = (0, import_toml.parse)(content);
+    const token = parsed["token"];
+    if (typeof token !== "string") return null;
+    const creds = { token };
+    if (typeof parsed["is_anonymous"] === "boolean") {
+      creds.is_anonymous = parsed["is_anonymous"];
+    }
+    if (typeof parsed["anonymous_id"] === "string") {
+      creds.anonymous_id = parsed["anonymous_id"];
+    }
+    if (typeof parsed["anonymous_secret"] === "string") {
+      creds.anonymous_secret = parsed["anonymous_secret"];
+    }
+    return creds;
+  }
+  async save(credentials) {
+    const fs = await import("fs/promises");
+    const nodePath = await import("path");
+    const filePath = await this.resolvePath();
+    const dir = nodePath.dirname(filePath);
+    await fs.mkdir(dir, { recursive: true, mode: 448 });
+    const data = {};
+    try {
+      const raw = await fs.readFile(filePath, "utf-8");
+      const parsed = (0, import_toml.parse)(raw);
+      for (const [k, v] of Object.entries(parsed)) {
+        if (typeof v === "string" || typeof v === "boolean" || typeof v === "number") {
+          data[k] = v;
+        }
+      }
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
+    data["token"] = credentials.token;
+    if (credentials.is_anonymous !== void 0) {
+      data["is_anonymous"] = credentials.is_anonymous;
+    }
+    if (credentials.anonymous_id !== void 0) {
+      data["anonymous_id"] = credentials.anonymous_id;
+    }
+    if (credentials.anonymous_secret !== void 0) {
+      data["anonymous_secret"] = credentials.anonymous_secret;
+    }
+    const toml = (0, import_toml.stringify)(
+      data
+    );
+    await fs.writeFile(filePath, toml, { mode: 384 });
+  }
+  async clear() {
+    const fs = await import("fs/promises");
+    const filePath = await this.resolvePath();
+    try {
+      await fs.unlink(filePath);
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
+  }
+};
+var MemoryCredentialStore = class {
+  credentials = null;
+  async load() {
+    return this.credentials ? { ...this.credentials } : null;
+  }
+  async save(credentials) {
+    this.credentials = {
+      token: credentials.token,
+      is_anonymous: credentials.is_anonymous ?? this.credentials?.is_anonymous,
+      anonymous_id: credentials.anonymous_id ?? this.credentials?.anonymous_id,
+      anonymous_secret: credentials.anonymous_secret ?? this.credentials?.anonymous_secret
+    };
+  }
+  async clear() {
+    this.credentials = null;
+  }
+};
+function defaultCredentialStore() {
+  return new FileCredentialStore();
+}
+
+// src/admin.ts
+function createAdminClient(options = {}) {
+  const baseUrl = options.baseUrl ?? "https://db9.shared.aws.tidbcloud.com/api";
+  const headers = {};
+  if (options.apiKey) {
+    headers["X-API-Key"] = options.apiKey;
+  }
+  const client = createHttpClient({
+    baseUrl,
+    fetch: options.fetch,
+    headers
+  });
+  return {
+    tenants: {
+      list: (params) => {
+        const queryParams = {};
+        if (params) {
+          if (params.page !== void 0)
+            queryParams.page = String(params.page);
+          if (params.size !== void 0)
+            queryParams.size = String(params.size);
+          if (params.state !== void 0) queryParams.state = params.state;
+          if (params.q !== void 0) queryParams.q = params.q;
+          if (params.cursor !== void 0) queryParams.cursor = params.cursor;
+          if (params.tag !== void 0) queryParams.tag = params.tag;
+        }
+        return client.get("/tenants", queryParams);
+      },
+      create: (req) => client.post("/tenants", req),
+      get: (tenantId) => client.get(`/tenants/${tenantId}`),
+      update: (tenantId, req) => client.put(`/tenants/${tenantId}`, req),
+      delete: (tenantId) => client.del(`/tenants/${tenantId}`),
+      remove: (tenantId) => client.post(`/tenants/${tenantId}/remove`),
+      batchCreate: (req) => client.post("/tenants/batch", req),
+      batchDelete: (req) => client.post("/tenants/batch/delete", req),
+      batchUpdate: (req) => client.put("/tenants/batch", req),
+      connect: (tenantId, req) => client.post(
+        `/tenants/${tenantId}/connect`,
+        req
+      ),
+      // query() needs X-Tenant-Session header — create a one-off client
+      query: async (tenantId, sessionId, req) => {
+        const sessionClient = createHttpClient({
+          baseUrl,
+          fetch: options.fetch,
+          headers: {
+            ...headers,
+            "X-Tenant-Session": sessionId
+          }
+        });
+        return sessionClient.post(
+          `/tenants/${tenantId}/query`,
+          req
+        );
+      }
+    },
+    system: {
+      health: () => client.get("/health"),
+      info: () => client.get("/info")
+    },
+    users: {
+      list: async (tenantId, sessionId) => {
+        const sessionClient = createHttpClient({
+          baseUrl,
+          fetch: options.fetch,
+          headers: {
+            ...headers,
+            "X-Tenant-Session": sessionId
+          }
+        });
+        return sessionClient.get(
+          `/tenants/${tenantId}/users`
+        );
+      },
+      create: async (tenantId, sessionId, req) => {
+        const sessionClient = createHttpClient({
+          baseUrl,
+          fetch: options.fetch,
+          headers: {
+            ...headers,
+            "X-Tenant-Session": sessionId
+          }
+        });
+        return sessionClient.post(
+          `/tenants/${tenantId}/users`,
+          req
+        );
+      },
+      delete: async (tenantId, sessionId, username) => {
+        const sessionClient = createHttpClient({
+          baseUrl,
+          fetch: options.fetch,
+          headers: {
+            ...headers,
+            "X-Tenant-Session": sessionId
+          }
+        });
+        return sessionClient.del(
+          `/tenants/${tenantId}/users/${username}`
+        );
+      },
+      resetPassword: async (tenantId, sessionId, username) => {
+        const sessionClient = createHttpClient({
+          baseUrl,
+          fetch: options.fetch,
+          headers: {
+            ...headers,
+            "X-Tenant-Session": sessionId
+          }
+        });
+        return sessionClient.post(
+          `/tenants/${tenantId}/users/${username}/password`
+        );
+      }
+    },
+    observability: {
+      get: (tenantId) => client.get(
+        `/tenants/${tenantId}/observability`
+      ),
+      bootstrap: (tenantId, req) => client.post(
+        `/tenants/${tenantId}/observability/bootstrap`,
+        req
+      )
+    },
+    audit: {
+      list: (params) => {
+        const queryParams = {};
+        if (params) {
+          if (params.tenant_id !== void 0)
+            queryParams.tenant_id = params.tenant_id;
+          if (params.operation_type !== void 0)
+            queryParams.operation_type = params.operation_type;
+          if (params.resource_type !== void 0)
+            queryParams.resource_type = params.resource_type;
+          if (params.success !== void 0)
+            queryParams.success = String(params.success);
+          if (params.limit !== void 0)
+            queryParams.limit = String(params.limit);
+          if (params.offset !== void 0)
+            queryParams.offset = String(params.offset);
+        }
+        return client.get("/audit-logs", queryParams);
+      }
+    }
+  };
+}
+
+// src/index.ts
+async function instantDatabase(options = {}) {
+  const store = options.credentialStore ?? defaultCredentialStore();
+  const dbName = options.name ?? "default";
+  const creds = await store.load();
+  let token;
+  if (creds?.token) {
+    token = creds.token;
+  } else {
+    const publicClient = createCustomerClient({
+      baseUrl: options.baseUrl,
+      fetch: options.fetch
+    });
+    const regResult = await publicClient.auth.anonymousRegister();
+    token = regResult.token;
+    await store.save({
+      token: regResult.token,
+      is_anonymous: regResult.is_anonymous,
+      anonymous_id: regResult.anonymous_id,
+      anonymous_secret: regResult.anonymous_secret
+    });
+  }
+  const client = createCustomerClient({
+    baseUrl: options.baseUrl,
+    fetch: options.fetch,
+    token
+  });
+  const existing = await client.databases.list();
+  const found = existing.find((db) => db.name === dbName);
+  if (found) {
+    return toResult(found);
+  }
+  const created = await client.databases.create({ name: dbName });
+  if (options.seed) {
+    await client.databases.sql(created.id, options.seed);
+  } else if (options.seedFile) {
+    await client.databases.sqlFile(created.id, options.seedFile);
+  }
+  return toResult(created);
+}
+function toResult(db) {
+  return {
+    databaseId: db.id,
+    connectionString: db.connection_string ?? "",
+    adminUser: db.admin_user ?? "",
+    adminPassword: db.admin_password ?? "",
+    state: db.state,
+    createdAt: db.created_at
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Db9AuthError,
+  Db9ConflictError,
+  Db9Error,
+  Db9NotFoundError,
+  FileCredentialStore,
+  MemoryCredentialStore,
+  createAdminClient,
+  createCustomerClient,
+  defaultCredentialStore,
+  instantDatabase
+});
+//# sourceMappingURL=index.cjs.map