@scarletdb/sdk 0.1.2 → 0.2.0

package/dist/index.mjs

@@ -77,19 +77,23 @@ var HttpClient = class {
         url += `?${queryString}`;
       }
     }
+    const authHeaders = await this.config.getAuthHeaders({ method, url });
     const requestHeaders = {
-      "Authorization": `Bearer ${this.config.apiKey}`,
-      "Content-Type": "application/json",
-      "Accept": "application/json",
+      Accept: "application/json",
+      ...authHeaders,
       ...headers
     };
+    const isFormData = typeof FormData !== "undefined" && body instanceof FormData;
+    if (body !== void 0 && !isFormData) {
+      requestHeaders["Content-Type"] = requestHeaders["Content-Type"] || "application/json";
+    }
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
     try {
       const response = await fetch(url, {
         method,
         headers: requestHeaders,
-        body: body ? JSON.stringify(body) : void 0,
+        body: body ? isFormData ? body : JSON.stringify(body) : void 0,
         signal: controller.signal
       });
       clearTimeout(timeoutId);
@@ -137,54 +141,29 @@ var HttpClient = class {
     }
   }
   // Convenience methods
-  async get(path, params) {
-    const response = await this.request({ method: "GET", path, params });
+  async get(path, params, headers) {
+    const response = await this.request({ method: "GET", path, params, headers });
     return response.data;
   }
-  async post(path, body) {
-    const response = await this.request({ method: "POST", path, body });
+  async post(path, body, headers) {
+    const response = await this.request({ method: "POST", path, body, headers });
     return response.data;
   }
-  async patch(path, body) {
-    const response = await this.request({ method: "PATCH", path, body });
+  async patch(path, body, headers) {
+    const response = await this.request({ method: "PATCH", path, body, headers });
     return response.data;
   }
-  async put(path, body) {
-    const response = await this.request({ method: "PUT", path, body });
+  async put(path, body, headers) {
+    const response = await this.request({ method: "PUT", path, body, headers });
     return response.data;
   }
-  async delete(path, body) {
-    const response = await this.request({ method: "DELETE", path, body });
+  async delete(path, body, headers) {
+    const response = await this.request({ method: "DELETE", path, body, headers });
     return response.data;
   }
-  /**
-   * Upload file using multipart/form-data
-   */
-  async upload(path, file, fileName) {
-    const formData = new FormData();
-    formData.append("file", file, fileName);
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout * 2);
-    try {
-      const response = await fetch(`${this.config.baseUrl}${path}`, {
-        method: "POST",
-        headers: {
-          "Authorization": `Bearer ${this.config.apiKey}`
-        },
-        body: formData,
-        signal: controller.signal
-      });
-      clearTimeout(timeoutId);
-      const data = await response.json();
-      if (!response.ok) {
-        this.handleErrorResponse(response.status, data);
-      }
-      return data;
-    } catch (error) {
-      clearTimeout(timeoutId);
-      if (error instanceof ScarletError) throw error;
-      throw new NetworkError("Upload failed", error);
-    }
+  async postForm(path, form) {
+    const response = await this.request({ method: "POST", path, body: form });
+    return response.data;
   }
 };
 
@@ -205,37 +184,41 @@ var QueryBuilder = class {
     this.client = client;
     this.table = table;
   }
-  _columns = [];
-  _where = {};
-  _orderBy;
+  _fields = [];
+  _filters = {};
+  _sort;
+  _page;
   _limit;
-  _offset;
   /**
    * Select specific columns (default: all)
    */
   select(...columns) {
-    this._columns = columns;
+    this._fields = columns;
     return this;
   }
   /**
    * Add where conditions
    */
   where(conditions) {
-    this._where = { ...this._where, ...conditions };
+    this._filters = { ...this._filters, ...conditions };
     return this;
   }
   /**
    * Add equality condition
    */
   eq(column, value) {
-    this._where[column] = value;
+    this._filters[column] = value;
     return this;
   }
   /**
    * Order results
    */
   orderBy(column, direction = "asc") {
-    this._orderBy = { column, direction };
+    this._sort = { column, direction };
+    return this;
+  }
+  page(page) {
+    this._page = page;
     return this;
   }
   /**
@@ -245,31 +228,47 @@ var QueryBuilder = class {
     this._limit = count;
     return this;
   }
-  /**
-   * Offset results (for pagination)
-   */
-  offset(count) {
-    this._offset = count;
-    return this;
+  buildQueryParams() {
+    const params = {};
+    const page = this._page ?? 1;
+    const limit = this._limit ?? void 0;
+    params.page = page;
+    if (limit !== void 0) params.limit = limit;
+    if (this._sort) {
+      params.sort = this._sort.direction === "desc" ? `-${this._sort.column}` : this._sort.column;
+    }
+    if (this._fields.length > 0) {
+      params.fields = this._fields.join(",");
+    }
+    for (const [field, value] of Object.entries(this._filters)) {
+      if (value === void 0) continue;
+      if (value && typeof value === "object" && !Array.isArray(value)) {
+        for (const [op, opValue] of Object.entries(value)) {
+          params[`filter[${field}][${op}]`] = String(opValue);
+        }
+      } else {
+        params[`filter[${field}]`] = String(value);
+      }
+    }
+    return params;
   }
   /**
    * Execute SELECT query
    */
   async execute() {
-    const params = {};
-    if (this._limit !== void 0) params.limit = this._limit;
-    if (this._offset !== void 0) params.offset = this._offset;
-    if (this._orderBy) {
-      params.sortBy = this._orderBy.column;
-      params.sortDir = this._orderBy.direction;
-    }
-    if (Object.keys(this._where).length > 0) {
-      params.search = JSON.stringify(this._where);
-    }
-    return this.client.get(
-      `/tables/${this.table}/rows`,
+    const params = this.buildQueryParams();
+    const res = await this.client.get(
+      `/${this.table}`,
       params
     );
+    const offset = ((res.meta.page || 1) - 1) * (res.meta.limit || 0);
+    return {
+      rows: res.data,
+      total: res.meta.total,
+      limit: res.meta.limit,
+      offset,
+      hasMore: res.meta.page < res.meta.totalPages
+    };
   }
   /**
    * Execute and return all rows
@@ -284,6 +283,7 @@ var QueryBuilder = class {
    */
   async single() {
     this._limit = 1;
+    this._page = 1;
     const result = await this.execute();
     return result.rows[0] ?? null;
   }
@@ -291,49 +291,51 @@ var QueryBuilder = class {
    * Insert data
    */
   async insert(data) {
-    return this.client.post(
-      `/tables/${this.table}/rows`,
-      Array.isArray(data) ? { rows: data } : data
-    );
+    if (Array.isArray(data)) {
+      const created2 = await Promise.all(data.map((row) => this.client.post(`/${this.table}`, row)));
+      return { success: true, rows: created2.map((r) => r.data) };
+    }
+    const created = await this.client.post(`/${this.table}`, data);
+    return { success: true, row: created.data };
   }
   /**
    * Update data (requires where clause)
    */
   async update(data) {
-    if (Object.keys(this._where).length === 0) {
-      throw new Error("Update requires at least one where condition for safety");
+    const id = this._filters["id"];
+    if (!id) {
+      throw new Error("Update requires an id filter");
     }
-    return this.client.patch(
-      `/tables/${this.table}/rows`,
-      { filters: this._where, data }
+    await this.client.patch(
+      `/${this.table}/${encodeURIComponent(String(id))}`,
+      data
     );
+    return { success: true, count: 1 };
   }
   /**
    * Delete data (requires where clause)
    */
   async delete() {
-    if (Object.keys(this._where).length === 0) {
-      throw new Error("Delete requires at least one where condition for safety");
+    const id = this._filters["id"];
+    if (!id) {
+      throw new Error("Delete requires an id filter");
     }
-    return this.client.delete(
-      `/tables/${this.table}/rows`,
-      { filters: this._where }
-    );
+    await this.client.delete(`/${this.table}/${encodeURIComponent(String(id))}`);
+    return { success: true, count: 1 };
   }
 };
 
 // src/modules/storage.ts
 var StorageModule = class {
-  constructor(client, baseUrl) {
+  constructor(client, projectId) {
     this.client = client;
-    this.baseUrl = baseUrl;
+    this.projectId = projectId;
   }
-  baseUrl;
   /**
    * Create a new storage bucket
    */
   async createBucket(name, options) {
-    return this.client.post("/storage/buckets", {
+    return this.client.post(`/storage/${this.projectId}/buckets`, {
       name,
       publicAccess: options?.publicAccess ?? false
     });
@@ -342,17 +344,20 @@ var StorageModule = class {
    * List all buckets
    */
   async listBuckets() {
-    return this.client.get("/storage/buckets");
+    return this.client.get(`/storage/${this.projectId}/buckets`);
   }
   /**
    * Upload a file to a bucket
    */
   async upload(bucket, file, options) {
+    const form = new FormData();
     const fileName = options?.fileName || (file instanceof File ? file.name : "file");
-    return this.client.upload(
-      `/storage/buckets/${bucket}/upload`,
-      file,
-      fileName
+    form.append("file", file, fileName);
+    if (options?.randomId !== void 0) form.append("randomId", String(options.randomId));
+    if (options?.cacheDuration !== void 0) form.append("cacheDuration", String(options.cacheDuration));
+    return this.client.postForm(
+      `/storage/${this.projectId}/buckets/${bucket}/upload`,
+      form
     );
   }
   /**
@@ -363,62 +368,63 @@ var StorageModule = class {
     if (options?.limit) params.limit = options.limit;
     if (options?.offset) params.offset = options.offset;
     if (options?.prefix) params.prefix = options.prefix;
-    return this.client.get(`/storage/buckets/${bucket}/files`, params);
+    return this.client.get(`/storage/${this.projectId}/buckets/${bucket}/files`, params);
   }
   /**
    * Get a signed URL for private file access
    */
   async getSignedUrl(bucket, fileName) {
     const result = await this.client.get(
-      `/storage/buckets/${bucket}/files/${encodeURIComponent(fileName)}/url`
+      `/storage/${this.projectId}/buckets/${bucket}/files/${encodeURIComponent(fileName)}/url`
     );
     return result.url;
   }
   /**
    * Get public URL for a file (bucket must be public)
    */
-  getPublicUrl(bucket, fileName) {
-    return `${this.baseUrl}/storage/buckets/${bucket}/files/${encodeURIComponent(fileName)}`;
-  }
   /**
    * Delete a file
    */
   async delete(bucket, fileName) {
     return this.client.delete(
-      `/storage/buckets/${bucket}/files/${encodeURIComponent(fileName)}`
+      `/storage/${this.projectId}/buckets/${bucket}/files/${encodeURIComponent(fileName)}`
     );
   }
   /**
    * Get storage statistics
    */
   async getStats() {
-    return this.client.get("/storage/stats");
+    return this.client.get(`/storage/${this.projectId}/stats`);
   }
 };
 
 // src/modules/email.ts
 var EmailModule = class {
-  constructor(client) {
+  constructor(client, projectId) {
     this.client = client;
+    this.projectId = projectId;
+  }
+  headers() {
+    return { "x-project-id": this.projectId };
   }
   /**
    * Send a transactional email
    */
   async send(options) {
-    return this.client.post("/email/send", options);
+    return this.client.post("/email/send", options, this.headers());
   }
   /**
    * Add a custom email domain
    */
   async addDomain(domain) {
-    const result = await this.client.post("/email/domains", { domain });
+    const result = await this.client.post("/email/domains", { domain }, this.headers());
     return result.domain;
   }
   /**
    * List configured email domains
    */
   async listDomains() {
-    const result = await this.client.get("/email/domains");
+    const result = await this.client.get("/email/domains", void 0, this.headers());
     return result.domains;
   }
   /**
@@ -426,7 +432,9 @@ var EmailModule = class {
    */
   async verifyDomain(domainId) {
     return this.client.post(
-      `/email/domains/${domainId}/verify`
+      `/email/domains/${domainId}/verify`,
+      {},
+      this.headers()
     );
   }
   /**
@@ -434,15 +442,16 @@ var EmailModule = class {
    */
   async getLogs(options) {
     const params = options?.limit ? { limit: options.limit } : void 0;
-    const result = await this.client.get("/email/logs", params);
+    const result = await this.client.get("/email/logs", params, this.headers());
     return result.logs;
   }
 };
 
 // src/modules/ai.ts
 var AIModule = class {
-  constructor(client) {
+  constructor(client, projectId) {
     this.client = client;
+    this.projectId = projectId;
   }
   /**
    * Execute a natural language query
@@ -454,61 +463,72 @@ var AIModule = class {
    * console.log(result.rows); // Query results
    */
   async query(prompt) {
-    return this.client.post("/ai/query", { prompt });
+    return this.client.post(`/ai/${this.projectId}/query`, { prompt });
   }
-  /**
-   * Generate SQL from natural language without executing
-   */
   async generateSQL(prompt) {
-    return this.client.post("/ai/generate", { prompt });
+    const result = await this.query(prompt);
+    return { sql: result.sql, explanation: result.explanation };
   }
 };
 
-// src/modules/sql.ts
-var SQLModule = class {
-  constructor(client) {
-    this.client = client;
-  }
-  /**
-   * Execute a parameterized SQL query
-   * 
-   * @example
-   * const result = await db.sql.query(
-   *   'SELECT * FROM users WHERE created_at > $1',
-   *   [new Date('2024-01-01')]
-   * );
-   */
-  async query(sql, params = []) {
-    return this.client.post("/query", { query: sql, params });
-  }
-  /**
-   * Execute raw SQL without parameter binding
-   * ⚠️ Use with caution - ensure input is sanitized
-   */
-  async unsafe(sql) {
-    return this.client.post("/query", { query: sql, params: [] });
-  }
-};
-function createSqlTag(client) {
-  return async function sql(strings, ...values) {
-    let query = "";
-    const params = [];
-    strings.forEach((str, i) => {
-      query += str;
-      if (i < values.length) {
-        params.push(values[i]);
-        query += `$${i + 1}`;
-      }
-    });
-    return client.post("/query", { query, params });
+// src/dpop.ts
+function base64urlEncode(data) {
+  let str = "";
+  for (let i = 0; i < data.length; i++) str += String.fromCharCode(data[i]);
+  const b64 = typeof btoa !== "undefined" ? btoa(str) : Buffer.from(data).toString("base64");
+  return b64.replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+}
+function base64urlEncodeJson(value) {
+  const json = JSON.stringify(value);
+  const bytes = new TextEncoder().encode(json);
+  return base64urlEncode(bytes);
+}
+function randomId() {
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function createDpopKey() {
+  const keyPair = await crypto.subtle.generateKey(
+    { name: "ECDSA", namedCurve: "P-256" },
+    true,
+    ["sign", "verify"]
+  );
+  const publicJwk = await crypto.subtle.exportKey("jwk", keyPair.publicKey);
+  return { keyPair, publicJwk };
+}
+async function createDpopProof(params) {
+  const header = {
+    typ: "dpop+jwt",
+    alg: "ES256",
+    jwk: await crypto.subtle.exportKey("jwk", params.keyPair.publicKey)
+  };
+  const now = Math.floor(Date.now() / 1e3);
+  const payload = {
+    htm: params.method.toUpperCase(),
+    htu: new URL(params.url).toString(),
+    iat: now,
+    jti: randomId(),
+    iss: "scarlet-dpop",
+    aud: "scarlet-sdk"
   };
+  const encodedHeader = base64urlEncodeJson(header);
+  const encodedPayload = base64urlEncodeJson(payload);
+  const signingInput = `${encodedHeader}.${encodedPayload}`;
+  const signature = await crypto.subtle.sign(
+    { name: "ECDSA", hash: "SHA-256" },
+    params.keyPair.privateKey,
+    new TextEncoder().encode(signingInput)
+  );
+  return `${signingInput}.${base64urlEncode(new Uint8Array(signature))}`;
 }
 
 // src/index.ts
-var DEFAULT_BASE_URL = "https://api.scarletdb.space/api/v1";
+var DEFAULT_URL = "https://api.scarletdb.space";
 var DEFAULT_TIMEOUT = 3e4;
 var Scarlet = class {
-  client;
+  engineClient;
+  coreClient;
   _data;
   /** Storage module for file operations */
   storage;
@@ -516,26 +536,68 @@ var Scarlet = class {
   email;
   /** AI module for natural language queries */
   ai;
-  /** SQL module for raw queries */
-  sql;
+  projectId;
   constructor(config) {
-    if (!config.apiKey) {
-      throw new Error("API key is required");
-    }
-    const baseUrl = config.baseUrl || DEFAULT_BASE_URL;
+    if (!config.projectId) throw new Error("projectId is required");
+    this.projectId = config.projectId;
+    const url = config.url || DEFAULT_URL;
+    const coreBaseUrl = `${(config.coreUrl || url).replace(/\/$/, "")}/api/v1`;
+    const engineBaseUrl = `${(config.engineUrl || url).replace(/\/$/, "")}/api/db/${this.projectId}`;
     const timeout = config.timeout || DEFAULT_TIMEOUT;
-    this.client = new HttpClient({
-      apiKey: config.apiKey,
-      baseUrl,
-      timeout
-    });
-    this._data = new DataModule(this.client);
-    this.storage = new StorageModule(this.client, baseUrl);
-    this.email = new EmailModule(this.client);
-    this.ai = new AIModule(this.client);
-    const sqlModule = new SQLModule(this.client);
-    const sqlTag = createSqlTag(this.client);
-    this.sql = Object.assign(sqlTag, sqlModule);
+    const tokenState = { value: "", expiresAt: 0 };
+    let dpopKey = null;
+    const getToken = async () => {
+      if (config.token) return config.token;
+      if (config.getToken) return config.getToken();
+      if (config.tokenEndpoint || config.publishableKey || !config.apiKey) {
+        const endpoint = config.tokenEndpoint || (config.publishableKey ? "/auth/publishable-token" : "/auth/sdk-token");
+        const now = Date.now();
+        if (tokenState.value && tokenState.expiresAt > now + 1e4) {
+          return tokenState.value;
+        }
+        if (config.enableDpop && !dpopKey) {
+          dpopKey = await createDpopKey();
+        }
+        const res = await fetch(`${coreBaseUrl}${endpoint}`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            ...config.publishableKey ? { "X-Publishable-Key": config.publishableKey } : {}
+          },
+          credentials: config.publishableKey ? "omit" : "include",
+          body: JSON.stringify({
+            projectId: this.projectId,
+            dpopJwk: dpopKey?.publicJwk
+          })
+        });
+        const json = await res.json().catch(() => ({}));
+        if (!res.ok) {
+          throw new Error((typeof json.error === "string" ? json.error : "") || "Failed to fetch token");
+        }
+        tokenState.value = String(json.token || "");
+        tokenState.expiresAt = Date.now() + Number(json.expiresIn || 0) * 1e3;
+        return tokenState.value;
+      }
+      throw new Error("Missing apiKey or token configuration");
+    };
+    const getAuthHeaders = async (params) => {
+      if (config.apiKey) {
+        return { "X-API-Key": config.apiKey };
+      }
+      const token = await getToken();
+      const headers = { Authorization: `Bearer ${token}` };
+      if (config.enableDpop) {
+        if (!dpopKey) dpopKey = await createDpopKey();
+        headers["DPoP"] = await createDpopProof({ keyPair: dpopKey.keyPair, method: params.method, url: params.url });
+      }
+      return headers;
+    };
+    this.engineClient = new HttpClient({ baseUrl: engineBaseUrl, timeout, getAuthHeaders });
+    this.coreClient = new HttpClient({ baseUrl: coreBaseUrl, timeout, getAuthHeaders });
+    this._data = new DataModule(this.engineClient);
+    this.storage = new StorageModule(this.coreClient, this.projectId);
+    this.email = new EmailModule(this.coreClient, this.projectId);
+    this.ai = new AIModule(this.coreClient, this.projectId);
   }
   /**
    * Start a query on a table
@@ -547,7 +609,10 @@ var Scarlet = class {
     return this._data.from(table);
   }
 };
+function createScarlet(config) {
+  return new Scarlet(config);
+}
 
-export { AuthenticationError, NetworkError, NotFoundError, QueryBuilder, RateLimitError, Scarlet, ScarletError, ValidationError };
+export { AuthenticationError, NetworkError, NotFoundError, QueryBuilder, RateLimitError, Scarlet, ScarletError, ValidationError, createScarlet };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map