@ezcoder.dev/sdk 1.0.0 → 1.2.0

package/dist/chunk-R4MDAYFO.js

@@ -0,0 +1,642 @@
+import {
+  ezcoder
+} from "./chunk-HJ2EIZ4S.js";
+import {
+  isSupabaseConfigured,
+  supabase
+} from "./chunk-I2YGB7Z6.js";
+import {
+  env,
+  features
+} from "./chunk-LIUE7M7K.js";
+
+// src/database/DatabaseProvider.tsx
+import { createContext, useContext, useMemo } from "react";
+
+// src/database/errors.ts
+var DatabaseError = class extends Error {
+  constructor(message, code = "DATABASE_ERROR", statusCode = 500) {
+    super(message);
+    this.name = "DatabaseError";
+    this.code = code;
+    this.statusCode = statusCode;
+  }
+};
+var QueryError = class extends DatabaseError {
+  constructor(message, sql) {
+    super(message, "QUERY_ERROR", 400);
+    this.name = "QueryError";
+    this.sql = sql;
+  }
+};
+var ValidationError = class extends DatabaseError {
+  constructor(message) {
+    super(message, "VALIDATION_ERROR", 422);
+    this.name = "ValidationError";
+  }
+};
+var ConnectionError = class extends DatabaseError {
+  constructor(message) {
+    super(message, "CONNECTION_ERROR", 503);
+    this.name = "ConnectionError";
+  }
+};
+var NotFoundError = class extends DatabaseError {
+  constructor(message = "Record not found") {
+    super(message, "NOT_FOUND", 404);
+    this.name = "NotFoundError";
+  }
+};
+function mapRpcError(rpcResult) {
+  if (rpcResult.success) return null;
+  const msg = rpcResult.error || "Unknown database error";
+  if (msg.includes("No database schema exists")) return new NotFoundError(msg);
+  if (msg.includes("Authentication required")) return new ConnectionError(msg);
+  if (msg.includes("blocked") || msg.includes("forbidden")) return new ValidationError(msg);
+  return new QueryError(msg);
+}
+
+// src/database/QueryBuilder.ts
+function escapeSqlValue(value) {
+  if (value === null) return "NULL";
+  if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new ValidationError("Non-finite numbers are not allowed");
+    return String(value);
+  }
+  return `'${String(value).replace(/'/g, "''")}'`;
+}
+function escapeIdentifier(name) {
+  if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
+    throw new ValidationError(`Invalid identifier: ${name}`);
+  }
+  return `"${name}"`;
+}
+var QueryBuilder = class {
+  constructor(supabase2, projectId, table, serverProxy) {
+    this.operation = "select";
+    this.selectColumns = "*";
+    this.filters = [];
+    this.orderClauses = [];
+    this.limitValue = null;
+    this.offsetValue = null;
+    this.insertData = null;
+    this.updateData = null;
+    this.upsertConflict = null;
+    this.singleMode = false;
+    this.maybeSingleMode = false;
+    this.supabase = supabase2;
+    this.projectId = projectId;
+    this.table = table;
+    this.serverProxy = serverProxy;
+  }
+  select(columns = "*") {
+    this.operation = "select";
+    this.selectColumns = columns;
+    return this;
+  }
+  // --- Filters ---
+  eq(column, value) {
+    this.filters.push({ column, op: "=", value });
+    return this;
+  }
+  neq(column, value) {
+    this.filters.push({ column, op: "!=", value });
+    return this;
+  }
+  gt(column, value) {
+    this.filters.push({ column, op: ">", value });
+    return this;
+  }
+  lt(column, value) {
+    this.filters.push({ column, op: "<", value });
+    return this;
+  }
+  gte(column, value) {
+    this.filters.push({ column, op: ">=", value });
+    return this;
+  }
+  lte(column, value) {
+    this.filters.push({ column, op: "<=", value });
+    return this;
+  }
+  like(column, pattern) {
+    this.filters.push({ column, op: "LIKE", value: pattern });
+    return this;
+  }
+  ilike(column, pattern) {
+    this.filters.push({ column, op: "ILIKE", value: pattern });
+    return this;
+  }
+  in(column, values) {
+    this.filters.push({ column, op: "IN", value: values });
+    return this;
+  }
+  is(column, value) {
+    this.filters.push({ column, op: "IS", value });
+    return this;
+  }
+  // --- Ordering & Pagination ---
+  order(column, options = {}) {
+    const dir = options.ascending === false ? "DESC" : "ASC";
+    const nulls = options.nullsFirst ? "NULLS FIRST" : "NULLS LAST";
+    this.orderClauses.push(`${escapeIdentifier(column)} ${dir} ${nulls}`);
+    return this;
+  }
+  limit(count) {
+    this.limitValue = count;
+    return this;
+  }
+  offset(count) {
+    this.offsetValue = count;
+    return this;
+  }
+  // --- Mutations ---
+  insert(records) {
+    this.operation = "insert";
+    this.insertData = Array.isArray(records) ? records : [records];
+    return this;
+  }
+  update(values) {
+    this.operation = "update";
+    this.updateData = values;
+    return this;
+  }
+  delete() {
+    this.operation = "delete";
+    return this;
+  }
+  upsert(records, options) {
+    this.operation = "upsert";
+    this.insertData = Array.isArray(records) ? records : [records];
+    this.upsertConflict = options?.onConflict || null;
+    return this;
+  }
+  // --- Result Helpers ---
+  count() {
+    this.operation = "count";
+    return this;
+  }
+  single() {
+    this.singleMode = true;
+    this.limitValue = 1;
+    return this;
+  }
+  maybeSingle() {
+    this.maybeSingleMode = true;
+    this.limitValue = 1;
+    return this;
+  }
+  // --- SQL Building ---
+  buildWhereClause() {
+    if (this.filters.length === 0) return "";
+    const conditions = this.filters.map((f) => {
+      const col = escapeIdentifier(f.column);
+      if (f.op === "IS") {
+        const val = f.value === null ? "NULL" : f.value ? "TRUE" : "FALSE";
+        return `${col} IS ${val}`;
+      }
+      if (f.op === "IN") {
+        const vals = f.value.map(escapeSqlValue).join(", ");
+        return `${col} IN (${vals})`;
+      }
+      return `${col} ${f.op} ${escapeSqlValue(f.value)}`;
+    });
+    return ` WHERE ${conditions.join(" AND ")}`;
+  }
+  buildSelectSql() {
+    let sql = `SELECT ${this.selectColumns} FROM "${this.table}"`;
+    sql += this.buildWhereClause();
+    if (this.orderClauses.length > 0) sql += ` ORDER BY ${this.orderClauses.join(", ")}`;
+    if (this.limitValue !== null) sql += ` LIMIT ${this.limitValue}`;
+    if (this.offsetValue !== null && this.offsetValue > 0) sql += ` OFFSET ${this.offsetValue}`;
+    return sql;
+  }
+  buildCountSql() {
+    let sql = `SELECT COUNT(*) as count FROM "${this.table}"`;
+    sql += this.buildWhereClause();
+    return sql;
+  }
+  buildInsertSql() {
+    if (!this.insertData || this.insertData.length === 0) {
+      throw new ValidationError("No data provided for insert");
+    }
+    const columns = Object.keys(this.insertData[0]);
+    const colList = columns.map(escapeIdentifier).join(", ");
+    const rows = this.insertData.map(
+      (row) => `(${columns.map((c) => escapeSqlValue(row[c] ?? null)).join(", ")})`
+    );
+    return `INSERT INTO "${this.table}" (${colList}) VALUES ${rows.join(", ")}`;
+  }
+  buildUpsertSql() {
+    let sql = this.buildInsertSql();
+    const conflict = this.upsertConflict || "id";
+    const columns = Object.keys(this.insertData[0]);
+    const updateCols = columns.filter((c) => c !== conflict).map((c) => `${escapeIdentifier(c)} = EXCLUDED.${escapeIdentifier(c)}`).join(", ");
+    sql += ` ON CONFLICT (${escapeIdentifier(conflict)}) DO UPDATE SET ${updateCols}`;
+    return sql;
+  }
+  buildUpdateSql() {
+    if (!this.updateData || Object.keys(this.updateData).length === 0) {
+      throw new ValidationError("No data provided for update");
+    }
+    if (this.filters.length === 0) {
+      throw new ValidationError("UPDATE without filters is not allowed \u2014 add .eq() or other filters");
+    }
+    const setClauses = Object.entries(this.updateData).map(([col, val]) => `${escapeIdentifier(col)} = ${escapeSqlValue(val)}`).join(", ");
+    return `UPDATE "${this.table}" SET ${setClauses}${this.buildWhereClause()}`;
+  }
+  buildDeleteSql() {
+    if (this.filters.length === 0) {
+      throw new ValidationError("DELETE without filters is not allowed \u2014 add .eq() or other filters");
+    }
+    return `DELETE FROM "${this.table}"${this.buildWhereClause()}`;
+  }
+  // --- Execution ---
+  async executeQuery() {
+    const isRead = this.operation === "select" || this.operation === "count";
+    let sql;
+    switch (this.operation) {
+      case "select":
+        sql = this.buildSelectSql();
+        break;
+      case "count":
+        sql = this.buildCountSql();
+        break;
+      case "insert":
+        sql = this.buildInsertSql();
+        break;
+      case "upsert":
+        sql = this.buildUpsertSql();
+        break;
+      case "update":
+        sql = this.buildUpdateSql();
+        break;
+      case "delete":
+        sql = this.buildDeleteSql();
+        break;
+      default:
+        throw new QueryError(`Unknown operation: ${this.operation}`);
+    }
+    if (this.serverProxy) {
+      const fn = isRead ? this.serverProxy.serverQuery : this.serverProxy.serverExec;
+      const data2 = await fn(sql);
+      if (!data2.success) {
+        const dbError = mapRpcError(data2);
+        if (dbError) throw dbError;
+        throw new QueryError(data2.error || "Query failed", sql);
+      }
+      return {
+        success: true,
+        data: isRead ? data2.data || [] : [],
+        rowCount: data2.rowCount ?? (isRead ? data2.data?.length || 0 : 0),
+        schema: data2.schema
+      };
+    }
+    const rpcName = isRead ? "sdk_query_project" : "sdk_exec_project";
+    const { data, error } = await this.supabase.rpc(rpcName, {
+      p_project_id: this.projectId,
+      p_sql: sql
+    });
+    if (error) {
+      throw new QueryError(error.message, sql);
+    }
+    if (!data.success) {
+      const dbError = mapRpcError(data);
+      if (dbError) throw dbError;
+      throw new QueryError(data.error || "Query failed", sql);
+    }
+    if (isRead) {
+      return {
+        success: true,
+        data: data.data || [],
+        rowCount: data.rowCount ?? (data.data?.length || 0),
+        schema: data.schema
+      };
+    }
+    return {
+      success: true,
+      data: [],
+      rowCount: data.rowCount ?? 0,
+      schema: data.schema
+    };
+  }
+  then(onfulfilled, onrejected) {
+    const promise = this.executeQuery().then((result) => {
+      if (this.singleMode) {
+        if (result.data.length === 0) {
+          throw new QueryError("Expected exactly one row, got 0");
+        }
+        return { success: true, data: result.data[0], error: void 0 };
+      }
+      if (this.maybeSingleMode) {
+        return {
+          success: true,
+          data: result.data.length > 0 ? result.data[0] : null,
+          error: void 0
+        };
+      }
+      return result;
+    });
+    return promise.then(onfulfilled, onrejected);
+  }
+};
+
+// src/database/DatabaseClient.ts
+function trackDbEvent(event, props) {
+  if (!features.analytics) return;
+  try {
+    ezcoder.analytics.track(event, props);
+  } catch {
+  }
+}
+var MAX_RETRIES = 3;
+var SERVER_TIMEOUT_MS = 5e3;
+var DatabaseClient = class _DatabaseClient {
+  constructor(supabase2, projectId) {
+    this.serverMode = false;
+    this.supabase = supabase2;
+    this.projectId = projectId;
+  }
+  static createServerClient(projectId, apiKey, platformUrl) {
+    const client = new _DatabaseClient(null, projectId);
+    client.apiKey = apiKey;
+    client.platformUrl = platformUrl || typeof process !== "undefined" && process.env?.EZCODER_API_URL || "https://ezcoder.app";
+    client.serverMode = true;
+    return client;
+  }
+  from(table) {
+    if (this.serverMode) {
+      return new QueryBuilder(null, this.projectId, table, {
+        serverQuery: (sql) => this._serverRequest("/query", sql),
+        serverExec: (sql) => this._serverRequest("/execute", sql)
+      });
+    }
+    return new QueryBuilder(this.supabase, this.projectId, table);
+  }
+  async sql(query) {
+    const trimmed = query.trim().toLowerCase();
+    if (!trimmed.startsWith("select")) {
+      throw new QueryError("sql() is for read-only queries. Use execute() for mutations.");
+    }
+    if (this.serverMode) {
+      return this._serverQuery(query);
+    }
+    const start = Date.now();
+    const { data, error } = await this.supabase.rpc("sdk_query_project", {
+      p_project_id: this.projectId,
+      p_sql: query
+    });
+    const latencyMs = Date.now() - start;
+    if (error) {
+      trackDbEvent("db_query", { projectId: this.projectId, latencyMs, success: false, error: error.message });
+      throw new QueryError(error.message, query);
+    }
+    if (!data.success) {
+      trackDbEvent("db_query", { projectId: this.projectId, latencyMs, success: false, error: data.error });
+      throw new QueryError(data.error || "Query failed", query);
+    }
+    trackDbEvent("db_query", { projectId: this.projectId, latencyMs, success: true, rowCount: data.rowCount ?? 0 });
+    return {
+      success: true,
+      data: data.data || [],
+      rowCount: data.rowCount ?? (data.data?.length || 0),
+      schema: data.schema
+    };
+  }
+  async execute(sql) {
+    if (this.serverMode) {
+      return this._serverExecute(sql);
+    }
+    const start = Date.now();
+    const { data, error } = await this.supabase.rpc("sdk_exec_project", {
+      p_project_id: this.projectId,
+      p_sql: sql
+    });
+    const latencyMs = Date.now() - start;
+    if (error) {
+      trackDbEvent("db_mutation", { projectId: this.projectId, latencyMs, success: false, error: error.message });
+      throw new QueryError(error.message, sql);
+    }
+    if (!data.success) {
+      trackDbEvent("db_mutation", { projectId: this.projectId, latencyMs, success: false, error: data.error });
+      throw new QueryError(data.error || "Execution failed", sql);
+    }
+    trackDbEvent("db_mutation", { projectId: this.projectId, latencyMs, success: true, rowCount: data.rowCount ?? 0 });
+    return {
+      success: true,
+      rowCount: data.rowCount ?? 0,
+      schema: data.schema,
+      executed_sql: data.executed_sql
+    };
+  }
+  async getSchema() {
+    if (this.serverMode) {
+      return this._serverGetSchema();
+    }
+    const { data, error } = await this.supabase.rpc("sdk_get_schema_info", {
+      p_project_id: this.projectId
+    });
+    if (error) throw new ConnectionError(error.message);
+    return {
+      exists: data.exists ?? false,
+      schema: data.schema,
+      tables: data.tables || [],
+      tablesCount: data.tablesCount ?? 0,
+      createdAt: data.createdAt,
+      lastAccessedAt: data.lastAccessedAt
+    };
+  }
+  async _serverRequest(endpoint, sql) {
+    const url = `${this.platformUrl}/api/platform/db/${this.projectId}${endpoint}`;
+    let lastError;
+    for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+      try {
+        const res = await fetch(url, {
+          method: "POST",
+          headers: {
+            "Authorization": `Bearer ${this.apiKey}`,
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({ sql }),
+          signal: AbortSignal.timeout(SERVER_TIMEOUT_MS)
+        });
+        if (res.status === 429) {
+          const retryAfter = parseInt(res.headers.get("retry-after") || "60", 10);
+          await new Promise((r) => setTimeout(r, retryAfter * 1e3));
+          continue;
+        }
+        if (res.status === 503) {
+          await new Promise((r) => setTimeout(r, (attempt + 1) * 2e3));
+          continue;
+        }
+        return await res.json();
+      } catch (e) {
+        lastError = e instanceof Error ? e : new Error(String(e));
+      }
+    }
+    return { success: false, error: lastError?.message || "Request failed after retries" };
+  }
+  async _serverQuery(query) {
+    const start = Date.now();
+    const result = await this._serverRequest("/query", query);
+    const latencyMs = Date.now() - start;
+    if (!result.success) {
+      trackDbEvent("db_query", { projectId: this.projectId, latencyMs, success: false, error: result.error, serverMode: true });
+      throw new QueryError(result.error || "Query failed", query);
+    }
+    trackDbEvent("db_query", { projectId: this.projectId, latencyMs, success: true, rowCount: result.rowCount ?? 0, serverMode: true });
+    return {
+      success: true,
+      data: result.data || [],
+      rowCount: result.rowCount ?? (result.data?.length || 0),
+      schema: result.schema
+    };
+  }
+  async _serverExecute(sql) {
+    const start = Date.now();
+    const result = await this._serverRequest("/execute", sql);
+    const latencyMs = Date.now() - start;
+    if (!result.success) {
+      trackDbEvent("db_mutation", { projectId: this.projectId, latencyMs, success: false, error: result.error, serverMode: true });
+      throw new QueryError(result.error || "Execution failed", sql);
+    }
+    trackDbEvent("db_mutation", { projectId: this.projectId, latencyMs, success: true, rowCount: result.rowCount ?? 0, serverMode: true });
+    return {
+      success: true,
+      rowCount: result.rowCount ?? 0,
+      schema: result.schema,
+      executed_sql: result.executed_sql
+    };
+  }
+  async _serverGetSchema() {
+    const url = `${this.platformUrl}/api/platform/db/${this.projectId}/schema`;
+    let lastError;
+    for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+      try {
+        const res = await fetch(url, {
+          method: "GET",
+          headers: { "Authorization": `Bearer ${this.apiKey}` },
+          signal: AbortSignal.timeout(SERVER_TIMEOUT_MS)
+        });
+        if (res.status === 503) {
+          await new Promise((r) => setTimeout(r, (attempt + 1) * 2e3));
+          continue;
+        }
+        const data = await res.json();
+        if (!data.success) throw new ConnectionError(data.error || "Schema fetch failed");
+        return {
+          exists: data.exists ?? false,
+          schema: data.schema,
+          tables: data.tables || [],
+          tablesCount: data.tablesCount ?? 0,
+          createdAt: data.createdAt,
+          lastAccessedAt: data.lastAccessedAt
+        };
+      } catch (e) {
+        lastError = e instanceof Error ? e : new Error(String(e));
+      }
+    }
+    throw new ConnectionError(lastError?.message || "Schema request failed after retries");
+  }
+};
+
+// src/database/DatabaseProvider.tsx
+import { jsx } from "react/jsx-runtime";
+var DatabaseContext = createContext({
+  db: null,
+  isConfigured: false
+});
+function DatabaseProvider({ children, projectId }) {
+  const resolvedProjectId = projectId || env.EZC_PROJECT_ID;
+  const configured = isSupabaseConfigured && Boolean(resolvedProjectId);
+  const db = useMemo(
+    () => configured ? new DatabaseClient(supabase, resolvedProjectId) : null,
+    [configured, resolvedProjectId]
+  );
+  const value = useMemo(() => ({ db, isConfigured: configured }), [db, configured]);
+  return /* @__PURE__ */ jsx(DatabaseContext.Provider, { value, children });
+}
+function useDatabase() {
+  const { db } = useContext(DatabaseContext);
+  if (!db) {
+    throw new Error(
+      "useDatabase() must be used within <DatabaseProvider>. Ensure EZC_PROJECT_ID and Supabase credentials are configured."
+    );
+  }
+  return db;
+}
+function useDatabaseOptional() {
+  const { db } = useContext(DatabaseContext);
+  return db;
+}
+function useIsDatabaseConfigured() {
+  const { isConfigured } = useContext(DatabaseContext);
+  return isConfigured;
+}
+
+// src/database/useRealtime.ts
+import { useEffect, useState, useRef } from "react";
+function useRealtime(table, options = {}) {
+  const [data, setData] = useState([]);
+  const [status, setStatus] = useState("connecting");
+  const optionsRef = useRef(options);
+  optionsRef.current = options;
+  const projectId = env.EZC_PROJECT_ID;
+  useEffect(() => {
+    if (!isSupabaseConfigured || !projectId) {
+      setStatus("disabled");
+      return;
+    }
+    const schemaName = `proj_${projectId.replace(/-/g, "_")}`;
+    const channelName = `${schemaName}_${table}_${optionsRef.current.event || "all"}`;
+    const channel = supabase.channel(channelName).on(
+      "postgres_changes",
+      {
+        event: optionsRef.current.event || "*",
+        schema: schemaName,
+        table,
+        filter: optionsRef.current.filter
+      },
+      (payload) => {
+        if (payload.eventType === "INSERT") {
+          setData((prev) => [...prev, payload.new]);
+        } else if (payload.eventType === "UPDATE") {
+          setData(
+            (prev) => prev.map(
+              (item) => item.id === payload.new.id ? payload.new : item
+            )
+          );
+        } else if (payload.eventType === "DELETE") {
+          setData(
+            (prev) => prev.filter(
+              (item) => item.id !== payload.old.id
+            )
+          );
+        }
+      }
+    ).subscribe((subStatus) => {
+      setStatus(subStatus === "SUBSCRIBED" ? "connected" : "connecting");
+    });
+    return () => {
+      supabase.removeChannel(channel);
+    };
+  }, [projectId, table]);
+  return { data, status, setData };
+}
+
+export {
+  DatabaseError,
+  QueryError,
+  ValidationError,
+  ConnectionError,
+  NotFoundError,
+  QueryBuilder,
+  DatabaseClient,
+  DatabaseProvider,
+  useDatabase,
+  useDatabaseOptional,
+  useIsDatabaseConfigured,
+  useRealtime
+};
+//# sourceMappingURL=chunk-R4MDAYFO.js.map