swiftbase-admin-sdk 1.0.0 → 1.0.2

package/dist/index.cjs

@@ -129,6 +129,9 @@ var init_token = __esm({
        * @returns {boolean} True if the API key is valid, false otherwise
        */
       isValid() {
+        if (__privateGet(this, _expiration) === 0) {
+          return true;
+        }
         return __privateGet(this, _expiration) > Date.now();
       }
       /**
@@ -217,7 +220,11 @@ var init_login = __esm({
       body.append("client_id", serviceId);
       body.append("client_secret", secretKey);
       body.append("scope", "openid profile email");
-      const url = `${app.baseUrl}/oauth2/token`;
+      let base = app.baseUrl || "https://api.swiftbase.io";
+      if (!base.includes("localhost") && !base.includes("127.0.0.1")) {
+        base = base.replace("api.swiftbase", "identity.swiftbase");
+      }
+      const url = `${base}/oauth2/token`;
       const response = yield fetch(url, {
         method: "POST",
         headers: {
@@ -3779,11 +3786,13 @@ var index_exports = {};
 __export(index_exports, {
   PaginatedResponse: () => PaginatedResponse,
   Storage: () => Storage,
+  ai: () => ai,
   app: () => app,
   assignRole: () => assignRole,
   changePassword: () => changePassword,
   createRole: () => createRole,
   createService: () => createService,
+  createUser: () => createUser,
   db: () => db,
   deleteRole: () => deleteRole,
   deleteService: () => deleteService,
@@ -3797,6 +3806,7 @@ __export(index_exports, {
   isLoggedIn: () => isLoggedIn,
   login: () => login,
   logout: () => logout,
+  search: () => search,
   setAccessToken: () => setAccessToken,
   unassignRole: () => unassignRole,
   updateConfiguration: () => updateConfiguration,
@@ -3836,19 +3846,6 @@ var TooManyRequests = class _TooManyRequests extends Error {
     Object.setPrototypeOf(this, _TooManyRequests.prototype);
   }
 };
-var handleRequestError = (status) => {
-  if (status === 401) {
-    throw new Unauthorized("Unauthorized");
-  } else if (status === 403) {
-    throw new Forbidden("Forbidden");
-  } else if (status === 400) {
-    throw new BadRequest("Bad Request");
-  } else if (status === 429) {
-    throw new TooManyRequests("Too Many Requests");
-  } else {
-    throw new Error("Unexpected error");
-  }
-};
 var _data, _meta;
 var PaginatedResponse = class {
   constructor(response) {
@@ -3903,7 +3900,17 @@ var makeRequest = (method, path, params, body) => __async(null, null, function*
   } else if (app.accessToken && app.accessToken.isValid()) {
     headers["Authorization"] = `Bearer ${app.accessToken.value()}`;
   }
-  let url = path.startsWith("http") ? path : `${app.baseUrl}${!path.startsWith("/") ? "/" : ""}${path}`;
+  let base = app.baseUrl || "https://api.swiftbase.io";
+  if (!base.includes("localhost") && !base.includes("127.0.0.1")) {
+    if (path.includes("/db/") || path.includes("/database") || path.includes("/tables") || path.includes("/sql") || path.includes("/queries")) {
+      base = base.replace("api.swiftbase", "database.swiftbase");
+    } else if (path.includes("/oauth2") || path.includes("/login") || path.includes("/api/roles") || path.includes("/api/services") || path.includes("/api/users") || path.includes("/api/me")) {
+      base = base.replace("api.swiftbase", "identity.swiftbase");
+    } else {
+      base = base.replace("api.swiftbase", "app.swiftbase");
+    }
+  }
+  let url = path.startsWith("http") ? path : `${base}${!path.startsWith("/") ? "/" : ""}${path}`;
   if (params) {
     const query = new URLSearchParams();
     for (const [key, value] of Object.entries(params)) {
@@ -3924,7 +3931,30 @@ var makeRequest = (method, path, params, body) => __async(null, null, function*
   try {
     const response = yield fetch(url, options);
     if (!response.ok) {
-      handleRequestError(response.status);
+      let message = "";
+      try {
+        const bodyText = yield response.text();
+        try {
+          const parsed = JSON.parse(bodyText);
+          message = parsed.message || parsed.error || bodyText;
+        } catch (e) {
+          message = bodyText;
+        }
+      } catch (_) {
+      }
+      const errorMsg = message ? `HTTP ${response.status}: ${message}` : `HTTP error ${response.status}`;
+      console.error(errorMsg);
+      if (response.status === 401) {
+        throw new Unauthorized(errorMsg);
+      } else if (response.status === 403) {
+        throw new Forbidden(errorMsg);
+      } else if (response.status === 400) {
+        throw new BadRequest(errorMsg);
+      } else if (response.status === 429) {
+        throw new TooManyRequests(errorMsg);
+      } else {
+        throw new Error(errorMsg);
+      }
     }
     const data = yield response.json();
     if (data.data !== void 0 && data.meta !== void 0) {
@@ -3948,7 +3978,11 @@ var verifyToken = (token) => __async(null, null, function* () {
   const headers = {
     "Authorization": `Bearer ${token}`
   };
-  const response = yield fetch(`${app.baseUrl}/api/me`, { headers });
+  let base = app.baseUrl || "https://api.swiftbase.io";
+  if (!base.includes("localhost") && !base.includes("127.0.0.1")) {
+    base = base.replace("api.swiftbase", "identity.swiftbase");
+  }
+  const response = yield fetch(`${base}/api/me`, { headers });
   if (!response.ok) {
     throw new Error(`Token verification failed: ${response.status}`);
   }
@@ -3958,7 +3992,11 @@ var verifyToken = (token) => __async(null, null, function* () {
 // src/auth/verifyservicetoken.ts
 init_app();
 var verifyServiceToken = (token, scope) => __async(null, null, function* () {
-  const url = `${app.baseUrl}/api/verify-service-token`;
+  let base = app.baseUrl || "https://api.swiftbase.io";
+  if (!base.includes("localhost") && !base.includes("127.0.0.1")) {
+    base = base.replace("api.swiftbase", "identity.swiftbase");
+  }
+  const url = `${base}/api/verify-service-token`;
   const response = yield fetch(url, {
     method: "POST",
     headers: {
@@ -4029,6 +4067,9 @@ var unassignRole = (userId, roleName) => __async(null, null, function* () {
   const roles = (user.roles || []).filter((r) => r !== roleName);
   return yield makeRequest("put" /* PUT */, `/api/users/${userId}`, void 0, { roles });
 });
+var createUser = (input) => __async(null, null, function* () {
+  return yield makeRequest("post" /* POST */, "/api/users", void 0, input);
+});
 
 // src/profile/getprofile.ts
 var getProfile = () => __async(null, null, function* () {
@@ -4076,7 +4117,7 @@ var _DatabaseSocketManager = class _DatabaseSocketManager {
     return _DatabaseSocketManager.instance;
   }
   isWebSocketAvailable() {
-    return this.socket !== null && (this.socket.readyState === 0 || this.socket.readyState === 1);
+    return this.socket !== null && this.socket.readyState === 1;
   }
   getWebSocketUrl(baseUrl, token) {
     let wsUrl = baseUrl.replace(/^http/, "ws");
@@ -4337,14 +4378,6 @@ var QueryBuilder = class {
   }
   execute() {
     return __async(this, null, function* () {
-      const socketManager = DatabaseSocketManager.getInstance();
-      if (socketManager.isWebSocketAvailable()) {
-        try {
-          return yield socketManager.executeQuery(this.payload);
-        } catch (err) {
-          console.warn("[QueryBuilder] WebSocket execution failed, falling back to REST:", err);
-        }
-      }
       return yield makeRequest("post" /* POST */, "/api/db/query", void 0, this.payload);
     });
   }
@@ -4353,9 +4386,115 @@ var QueryBuilder = class {
   }
 };
 function db(dbName) {
-  return function(tableName) {
+  const dbClient = function(tableName) {
     return new QueryBuilder(dbName, tableName);
   };
+  dbClient.initializeDatabase = function(tables) {
+    return __async(this, null, function* () {
+      const projectId = app.projectId;
+      let dbs = [];
+      try {
+        dbs = yield makeRequest("get" /* GET */, "/api/databases", { projectId });
+      } catch (err) {
+        console.error("[DatabaseInit] Failed to list databases:", err.message);
+        throw err;
+      }
+      let myDb = dbs.find((d) => d.name === dbName);
+      if (!myDb) {
+        console.log(`[DatabaseInit] Database '${dbName}' not found. Creating...`);
+        try {
+          myDb = yield makeRequest("post" /* POST */, "/api/databases", void 0, {
+            name: dbName,
+            projectId,
+            engine: "oltp",
+            enableGraphQL: true
+          });
+        } catch (err) {
+          console.error("[DatabaseInit] Failed to create database:", err.message);
+          throw err;
+        }
+      }
+      const databaseId = myDb.id;
+      const schemaName = dbName.toLowerCase().replace(/[^a-z0-9_]/g, "_");
+      let existingTables = [];
+      try {
+        existingTables = yield makeRequest("get" /* GET */, "/api/tables", { databaseId });
+      } catch (err) {
+        console.error("[DatabaseInit] Failed to list tables:", err.message);
+        throw err;
+      }
+      for (const t of tables) {
+        try {
+          yield makeRequest("post" /* POST */, "/api/sql", void 0, {
+            databaseId,
+            sql: t.ddl
+          });
+        } catch (err) {
+          console.error(`[DatabaseInit] Failed to execute DDL for table ${t.dbname}:`, err.message);
+          throw err;
+        }
+        const metaExists = existingTables.some((meta) => meta.dbname === t.dbname);
+        if (!metaExists) {
+          try {
+            yield makeRequest("post" /* POST */, "/api/tables", void 0, {
+              databaseId,
+              dbname: t.dbname,
+              name: t.name,
+              docName: t.dbname,
+              rules: "true"
+            });
+          } catch (err) {
+            console.error(`[DatabaseInit] Failed to register metadata for table ${t.dbname}:`, err.message);
+            throw err;
+          }
+        }
+      }
+    });
+  };
+  dbClient.executeSQL = function(sql) {
+    return __async(this, null, function* () {
+      const projectId = app.projectId;
+      let dbs = [];
+      try {
+        dbs = yield makeRequest("get" /* GET */, "/api/databases", { projectId });
+      } catch (err) {
+        console.error("[DatabaseSQL] Failed to list databases:", err.message);
+        throw err;
+      }
+      const myDb = dbs.find((d) => d.name === dbName);
+      if (!myDb) throw new Error(`Database ${dbName} not found`);
+      return yield makeRequest("post" /* POST */, "/api/sql", void 0, {
+        databaseId: myDb.id,
+        sql
+      });
+    });
+  };
+  return dbClient;
+}
+
+// src/database/search.ts
+init_app();
+function search(indexId, query) {
+  return __async(this, null, function* () {
+    if (!indexId || !query) {
+      throw new Error("indexId and query are required to perform a search");
+    }
+    const baseUrl = app.baseUrl || "https://api.swiftbase.io";
+    const token = app.accessToken || "";
+    const res = yield fetch(`${baseUrl}/api/search/query`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": token ? `Bearer ${token}` : ""
+      },
+      body: JSON.stringify({ indexId, query })
+    });
+    if (!res.ok) {
+      throw new Error("Failed to execute search query against Swiftbase indexes");
+    }
+    const data = yield res.json();
+    return data || [];
+  });
 }
 
 // src/storage/storage.ts
@@ -4683,15 +4822,31 @@ var Storage = class {
     });
   }
 };
+
+// src/ai/index.ts
+var ai = {
+  chat: {
+    completions: {
+      create: (options) => __async(null, null, function* () {
+        return yield makeRequest("post" /* POST */, "/api/ai/chat/completions", void 0, {
+          model: options.model || "gemini-3.5-flash",
+          messages: options.messages
+        });
+      })
+    }
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   PaginatedResponse,
   Storage,
+  ai,
   app,
   assignRole,
   changePassword,
   createRole,
   createService,
+  createUser,
   db,
   deleteRole,
   deleteService,
@@ -4705,6 +4860,7 @@ var Storage = class {
   isLoggedIn,
   login,
   logout,
+  search,
   setAccessToken,
   unassignRole,
   updateConfiguration,