@vaiftechnologies/vaif-client 0.1.1 → 0.2.0

package/dist/{index.mjs → index.cjs}

@@ -1,3 +1,166 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  RealtimeChannel: () => RealtimeChannel,
+  VaifAI: () => VaifAI,
+  VaifAdmin: () => VaifAdmin,
+  VaifApiKeys: () => VaifApiKeys,
+  VaifAuth: () => VaifAuth,
+  VaifAuthError: () => VaifAuthError,
+  VaifClient: () => VaifClient,
+  VaifConflictError: () => VaifConflictError,
+  VaifDatabase: () => VaifDatabase,
+  VaifError: () => VaifError,
+  VaifFunctions: () => VaifFunctions,
+  VaifIntegrations: () => VaifIntegrations,
+  VaifNetworkError: () => VaifNetworkError,
+  VaifNotFoundError: () => VaifNotFoundError,
+  VaifProjects: () => VaifProjects,
+  VaifRateLimitError: () => VaifRateLimitError,
+  VaifRealtime: () => VaifRealtime,
+  VaifSchema: () => VaifSchema,
+  VaifStorage: () => VaifStorage,
+  VaifTimeoutError: () => VaifTimeoutError,
+  VaifTypeGen: () => VaifTypeGen,
+  VaifValidationError: () => VaifValidationError,
+  createClient: () => createClient,
+  createTypeGen: () => createTypeGen,
+  createVaifClient: () => createClient,
+  isVaifAuthError: () => isVaifAuthError,
+  isVaifConflictError: () => isVaifConflictError,
+  isVaifError: () => isVaifError,
+  isVaifNetworkError: () => isVaifNetworkError,
+  isVaifNotFoundError: () => isVaifNotFoundError,
+  isVaifRateLimitError: () => isVaifRateLimitError,
+  isVaifTimeoutError: () => isVaifTimeoutError,
+  isVaifValidationError: () => isVaifValidationError
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var VaifError = class _VaifError extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = "VaifError";
+    this.code = options.code;
+    this.statusCode = options.statusCode;
+    this.requestId = options.requestId;
+    this.details = options.details;
+    const ErrorWithCapture = Error;
+    if (ErrorWithCapture.captureStackTrace) {
+      ErrorWithCapture.captureStackTrace(this, _VaifError);
+    }
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      statusCode: this.statusCode,
+      requestId: this.requestId,
+      details: this.details
+    };
+  }
+};
+var VaifAuthError = class extends VaifError {
+  constructor(message, options) {
+    super(message, {
+      code: options?.code ?? "AUTH_ERROR",
+      statusCode: options?.statusCode ?? 401,
+      requestId: options?.requestId
+    });
+    this.name = "VaifAuthError";
+  }
+};
+var VaifValidationError = class extends VaifError {
+  constructor(message, options) {
+    super(message, {
+      code: "VALIDATION_ERROR",
+      statusCode: 400,
+      requestId: options?.requestId,
+      details: options?.details ?? options?.fieldErrors
+    });
+    this.name = "VaifValidationError";
+    this.fieldErrors = options?.fieldErrors;
+  }
+};
+var VaifNetworkError = class extends VaifError {
+  constructor(message, cause) {
+    super(message, { code: "NETWORK_ERROR" });
+    this.name = "VaifNetworkError";
+    this.cause = cause;
+  }
+};
+var VaifRateLimitError = class extends VaifError {
+  constructor(message, retryAfter) {
+    super(message, { code: "RATE_LIMITED", statusCode: 429 });
+    this.name = "VaifRateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var VaifNotFoundError = class extends VaifError {
+  constructor(message, requestId) {
+    super(message, { code: "NOT_FOUND", statusCode: 404, requestId });
+    this.name = "VaifNotFoundError";
+  }
+};
+var VaifConflictError = class extends VaifError {
+  constructor(message, requestId) {
+    super(message, { code: "CONFLICT", statusCode: 409, requestId });
+    this.name = "VaifConflictError";
+  }
+};
+var VaifTimeoutError = class extends VaifNetworkError {
+  constructor(message, timeoutMs) {
+    super(message);
+    this.name = "VaifTimeoutError";
+    this.timeoutMs = timeoutMs;
+  }
+};
+function isVaifError(error) {
+  return error instanceof VaifError;
+}
+function isVaifAuthError(error) {
+  return error instanceof VaifAuthError;
+}
+function isVaifValidationError(error) {
+  return error instanceof VaifValidationError;
+}
+function isVaifNetworkError(error) {
+  return error instanceof VaifNetworkError;
+}
+function isVaifRateLimitError(error) {
+  return error instanceof VaifRateLimitError;
+}
+function isVaifNotFoundError(error) {
+  return error instanceof VaifNotFoundError;
+}
+function isVaifConflictError(error) {
+  return error instanceof VaifConflictError;
+}
+function isVaifTimeoutError(error) {
+  return error instanceof VaifTimeoutError;
+}
+
 // src/lib/database.ts
 var VaifDatabase = class {
   constructor(client) {
@@ -6,6 +169,9 @@ var VaifDatabase = class {
   /**
    * Start a query on a table
    *
+   * @param table - Table name to query
+   * @returns A query builder for chaining operations
+   *
    * @example
    * ```typescript
    * const users = await vaif.db.from('users').select('*').execute();
@@ -17,6 +183,10 @@ var VaifDatabase = class {
   /**
    * Execute raw SQL query (admin only)
    *
+   * @param sql - SQL query string with $1, $2, etc. parameter placeholders
+   * @param params - Parameter values for the query
+   * @returns Query result with typed rows
+   *
    * @example
    * ```typescript
    * const result = await vaif.db.raw('SELECT * FROM users WHERE id = $1', [userId]);
@@ -44,7 +214,16 @@ var VaifDatabase = class {
     };
   }
   /**
-   * Execute a function (stored procedure)
+   * Execute a stored procedure (RPC call)
+   *
+   * @param functionName - Name of the database function to call
+   * @param params - Parameters to pass to the function
+   * @returns Query result with the function's return value
+   *
+   * @example
+   * ```typescript
+   * const result = await vaif.db.rpc('get_user_stats', { userId: '123' });
+   * ```
    */
   async rpc(functionName, params) {
     const response = await this.client.request(`/db/rpc/${functionName}`, {
@@ -133,72 +312,85 @@ var QueryBuilder = class {
     this.onConflictUpdate = data;
     return this;
   }
-  // Filter methods
+  /** Filter by equality (column = value) */
   eq(column, value) {
     this.addFilter(column, this.negateNext ? "neq" : "eq", value);
     this.negateNext = false;
     return this;
   }
+  /** Filter by inequality (column != value) */
   neq(column, value) {
     this.addFilter(column, this.negateNext ? "eq" : "neq", value);
     this.negateNext = false;
     return this;
   }
+  /** Filter by greater than (column > value) */
   gt(column, value) {
     this.addFilter(column, this.negateNext ? "lte" : "gt", value);
     this.negateNext = false;
     return this;
   }
+  /** Filter by greater than or equal (column >= value) */
   gte(column, value) {
     this.addFilter(column, this.negateNext ? "lt" : "gte", value);
     this.negateNext = false;
     return this;
   }
+  /** Filter by less than (column < value) */
   lt(column, value) {
     this.addFilter(column, this.negateNext ? "gte" : "lt", value);
     this.negateNext = false;
     return this;
   }
+  /** Filter by less than or equal (column <= value) */
   lte(column, value) {
     this.addFilter(column, this.negateNext ? "gt" : "lte", value);
     this.negateNext = false;
     return this;
   }
+  /** Filter by pattern matching (case-sensitive LIKE) */
   like(column, pattern) {
     this.addFilter(column, this.negateNext ? "nlike" : "like", pattern);
     this.negateNext = false;
     return this;
   }
+  /** Filter by pattern matching (case-insensitive ILIKE) */
   ilike(column, pattern) {
     this.addFilter(column, this.negateNext ? "nilike" : "ilike", pattern);
     this.negateNext = false;
     return this;
   }
+  /** Filter by IS (null/boolean checks) */
   is(column, value) {
     this.addFilter(column, this.negateNext ? "isnot" : "is", value);
     this.negateNext = false;
     return this;
   }
+  /** Filter by inclusion in an array of values */
   in(column, values) {
     this.addFilter(column, this.negateNext ? "nin" : "in", values);
     this.negateNext = false;
     return this;
   }
+  /** Filter by array containment (@>) */
   contains(column, value) {
     this.addFilter(column, "cs", value);
     this.negateNext = false;
     return this;
   }
+  /** Filter by array being contained by (<@) */
   containedBy(column, value) {
     this.addFilter(column, "cd", value);
     this.negateNext = false;
     return this;
   }
+  /** Filter by array overlap (&&) */
   overlaps(column, value) {
     this.addFilter(column, "ov", value);
     this.negateNext = false;
     return this;
   }
+  /** Full-text search filter */
   textSearch(column, query, options) {
     this.addFilter(column, "fts", query, options?.config);
     this.negateNext = false;
@@ -1813,6 +2005,42 @@ var VaifAI = class {
     }
     return { data: response.data, error: null };
   }
+  /**
+   * Generate a plan for schema or other tasks using AI
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await vaif.ai.generatePlan({
+   *   projectId: 'your-project-id',
+   *   prompt: 'Create a users table with email and password',
+   *   taskType: 'plan_schema',
+   *   mode: 'balanced'
+   * });
+   * ```
+   */
+  async generatePlan(request) {
+    const response = await this.client.request("/ai/plan", {
+      method: "POST",
+      body: request
+    });
+    if (response.error) {
+      return {
+        ok: false,
+        plan: { steps: [] },
+        costEstimateCents: 0,
+        error: {
+          message: response.error.message,
+          code: response.error.code,
+          status: response.status
+        }
+      };
+    }
+    return response.data ?? {
+      ok: false,
+      plan: { steps: [] },
+      costEstimateCents: 0
+    };
+  }
   /**
    * Generate SQL migration from schema diff
    */
@@ -1838,6 +2066,260 @@ var VaifAI = class {
     }
     return { data: response.data, error: null };
   }
+  /**
+   * Get Copilot observability metrics for the current project
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await vaif.ai.getCopilotMetrics({ range: '24h' });
+   * console.log(`Success rate: ${data.summary.successRate}%`);
+   * console.log(`Total tokens: ${data.summary.totalTokens}`);
+   * ```
+   */
+  async getCopilotMetrics(options = {}) {
+    const config = this.client.getConfig();
+    const range = options.range ?? "24h";
+    const response = await this.client.request(
+      `/copilot/metrics/${config.projectId}?range=${range}`,
+      { method: "GET" }
+    );
+    if (response.error) {
+      return {
+        data: null,
+        error: {
+          message: response.error.message,
+          code: response.error.code,
+          status: response.status
+        }
+      };
+    }
+    return { data: response.data, error: null };
+  }
+  /**
+   * Get Copilot observability metrics for an organization
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await vaif.ai.getCopilotOrgMetrics(orgId, { range: '7d' });
+   * console.log(`Total requests: ${data.summary.totalRequests}`);
+   * console.log(`Projects: ${data.summary.uniqueProjects}`);
+   * ```
+   */
+  async getCopilotOrgMetrics(orgId, options = {}) {
+    const range = options.range ?? "24h";
+    const response = await this.client.request(
+      `/copilot/metrics/org/${orgId}?range=${range}`,
+      { method: "GET" }
+    );
+    if (response.error) {
+      return {
+        data: null,
+        error: {
+          message: response.error.message,
+          code: response.error.code,
+          status: response.status
+        }
+      };
+    }
+    return { data: response.data, error: null };
+  }
+};
+
+// src/lib/schema.ts
+var VaifSchema = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Preview schema changes without applying them
+   *
+   * @example
+   * ```typescript
+   * const result = await vaif.schema.preview({
+   *   projectId: 'your-project-id',
+   *   definition: {
+   *     tables: [
+   *       { name: 'users', columns: [{ name: 'id', type: 'uuid', primaryKey: true }] }
+   *     ]
+   *   }
+   * });
+   *
+   * if (result.ok) {
+   *   console.log('Plan steps:', result.plan);
+   *   console.log('SQL:', result.upSql);
+   * }
+   * ```
+   */
+  async preview(request) {
+    const response = await this.client.request(
+      "/schema-engine/preview",
+      {
+        method: "POST",
+        body: request
+      }
+    );
+    if (response.error) {
+      return {
+        ok: false,
+        projectSchema: "",
+        plan: [],
+        upSql: "",
+        downSql: "",
+        warnings: [],
+        error: {
+          message: response.error.message,
+          code: response.error.code,
+          status: response.status,
+          details: response.error.details
+        }
+      };
+    }
+    return response.data ?? {
+      ok: false,
+      projectSchema: "",
+      plan: [],
+      upSql: "",
+      downSql: "",
+      warnings: []
+    };
+  }
+  /**
+   * Apply schema changes to the database
+   *
+   * @example
+   * ```typescript
+   * const result = await vaif.schema.apply({
+   *   projectId: 'your-project-id',
+   *   definition: {
+   *     tables: [
+   *       { name: 'users', columns: [{ name: 'id', type: 'uuid', primaryKey: true }] }
+   *     ]
+   *   },
+   *   migrationName: 'add_users_table'
+   * });
+   *
+   * if (result.ok) {
+   *   console.log('Applied:', result.appliedSteps, 'steps');
+   * }
+   * ```
+   */
+  async apply(request) {
+    const response = await this.client.request(
+      "/schema-engine/apply",
+      {
+        method: "POST",
+        body: request
+      }
+    );
+    if (response.error) {
+      return {
+        ok: false,
+        projectSchema: "",
+        migration: {
+          id: "",
+          name: "",
+          status: "failed",
+          appliedAt: ""
+        },
+        appliedSteps: 0,
+        error: {
+          message: response.error.message,
+          code: response.error.code,
+          status: response.status,
+          details: response.error.details
+        }
+      };
+    }
+    return response.data ?? {
+      ok: false,
+      projectSchema: "",
+      migration: {
+        id: "",
+        name: "",
+        status: "failed",
+        appliedAt: ""
+      },
+      appliedSteps: 0
+    };
+  }
+  /**
+   * Introspect current database schema
+   *
+   * @example
+   * ```typescript
+   * const result = await vaif.schema.introspect('your-project-id');
+   *
+   * if (result.ok) {
+   *   console.log('Tables:', result.tables);
+   * }
+   * ```
+   */
+  async introspect(projectId, envId) {
+    const params = {};
+    if (envId) {
+      params.envId = envId;
+    }
+    const response = await this.client.request(
+      `/schema-engine/introspect/${projectId}`,
+      { params }
+    );
+    if (response.error) {
+      return {
+        ok: false,
+        schemaExists: false,
+        tables: [],
+        error: {
+          message: response.error.message,
+          code: response.error.code,
+          status: response.status
+        }
+      };
+    }
+    return response.data ?? {
+      ok: false,
+      schemaExists: false,
+      tables: []
+    };
+  }
+  /**
+   * Get migration history for a project
+   *
+   * @example
+   * ```typescript
+   * const result = await vaif.schema.getMigrations('your-project-id');
+   *
+   * if (result.ok) {
+   *   for (const migration of result.migrations) {
+   *     console.log(migration.name, migration.status);
+   *   }
+   * }
+   * ```
+   */
+  async getMigrations(projectId, options) {
+    const params = {};
+    if (options?.limit) {
+      params.limit = String(options.limit);
+    }
+    const response = await this.client.request(
+      `/schema-engine/migrations/project/${projectId}`,
+      { params }
+    );
+    if (response.error) {
+      return {
+        ok: false,
+        migrations: [],
+        error: {
+          message: response.error.message,
+          code: response.error.code,
+          status: response.status
+        }
+      };
+    }
+    return response.data ?? {
+      ok: false,
+      migrations: []
+    };
+  }
 };
 
 // src/lib/typegen.ts
@@ -1958,7 +2440,7 @@ var VaifTypeGen = class {
         lines.push("");
       }
     }
-    let filteredTables = dbSchema.tables.filter((t) => {
+    const filteredTables = dbSchema.tables.filter((t) => {
       if (tables.length > 0 && !tables.includes(t.name)) return false;
       if (excludeTables.includes(t.name)) return false;
       return true;
@@ -2050,7 +2532,7 @@ var VaifTypeGen = class {
         lines.push("");
       }
     }
-    let filteredTables = (schema.tables || []).filter((t) => {
+    const filteredTables = (schema.tables || []).filter((t) => {
       if (tables.length > 0 && !tables.includes(t.name)) return false;
       if (excludeTables.includes(t.name)) return false;
       return true;
@@ -2442,55 +2924,631 @@ var VaifAdmin = class {
   }
 };
 
-// src/lib/client.ts
-var DEFAULT_API_URL = "https://api.vaif.studio";
-var DEFAULT_REALTIME_URL = "wss://realtime.vaif.studio";
-var DEFAULT_TIMEOUT = 3e4;
-var memoryStorage = {
-  data: /* @__PURE__ */ new Map(),
-  getItem(key) {
-    return this.data.get(key) ?? null;
-  },
-  setItem(key, value) {
-    this.data.set(key, value);
-  },
-  removeItem(key) {
-    this.data.delete(key);
+// src/lib/projects.ts
+var VaifProjects = class {
+  constructor(client) {
+    this.client = client;
   }
-};
-var browserStorage = typeof window !== "undefined" && window.localStorage ? {
-  getItem: (key) => window.localStorage.getItem(key),
-  setItem: (key, value) => window.localStorage.setItem(key, value),
-  removeItem: (key) => window.localStorage.removeItem(key)
-} : null;
-function createClient(options) {
-  return new VaifClient(options);
-}
-var VaifClient = class {
-  constructor(options) {
-    this.accessToken = null;
-    const isAdminClient = options.baseUrl || options.accessToken;
-    if (!isAdminClient) {
-      if (!options.projectId) {
-        throw new Error("projectId is required");
-      }
-      if (!options.apiKey) {
-        throw new Error("apiKey is required");
-      }
+  /**
+   * List all projects the user has access to
+   */
+  async list(options) {
+    const params = {};
+    if (options?.orgId) {
+      params.orgId = options.orgId;
     }
-    this.config = {
-      projectId: options.projectId ?? "",
-      apiKey: options.apiKey ?? "",
-      apiKeyHeader: options.apiKeyHeader ?? "apikey",
-      apiUrl: options.baseUrl ?? options.apiUrl ?? DEFAULT_API_URL,
-      realtimeUrl: options.realtimeUrl ?? DEFAULT_REALTIME_URL,
-      timeout: options.timeout ?? DEFAULT_TIMEOUT,
-      headers: options.headers ?? {},
-      debug: options.debug ?? false,
-      autoRefreshToken: options.autoRefreshToken ?? true,
-      persistSession: options.persistSession ?? true,
-      storage: options.storage ?? browserStorage ?? memoryStorage
-    };
+    const response = await this.client.request("/projects", { params });
+    if (response.error) {
+      throw new Error(response.error.message);
+    }
+    return response.data ?? [];
+  }
+  /**
+   * Get a specific project by ID
+   */
+  async get(projectId) {
+    const response = await this.client.request(
+      `/projects/${projectId}`
+    );
+    if (response.error) {
+      throw new Error(response.error.message);
+    }
+    return response.data ?? { project: {}, environments: [] };
+  }
+  /**
+   * Create a new project
+   */
+  async create(options) {
+    const response = await this.client.request(
+      "/projects",
+      {
+        method: "POST",
+        body: options
+      }
+    );
+    if (response.error) {
+      throw new Error(response.error.message);
+    }
+    return response.data ?? { project: {}, environments: [] };
+  }
+  /**
+   * Update a project
+   */
+  async update(projectId, options) {
+    const response = await this.client.request(
+      `/projects/${projectId}`,
+      {
+        method: "PATCH",
+        body: options
+      }
+    );
+    if (response.error) {
+      throw new Error(response.error.message);
+    }
+    return response.data ?? { project: {} };
+  }
+  /**
+   * Delete a project
+   */
+  async delete(projectId) {
+    const response = await this.client.request(
+      `/projects/${projectId}`,
+      {
+        method: "DELETE"
+      }
+    );
+    if (response.error) {
+      throw new Error(response.error.message);
+    }
+  }
+  /**
+   * List API keys for a project
+   */
+  async listApiKeys(projectId) {
+    const response = await this.client.request(
+      `/projects/${projectId}/api-keys`
+    );
+    if (response.error) {
+      throw new Error(response.error.message);
+    }
+    return response.data?.keys ?? [];
+  }
+  /**
+   * Alias for listApiKeys
+   */
+  async getApiKeys(projectId) {
+    return this.listApiKeys(projectId);
+  }
+  /**
+   * Create an API key for a project
+   */
+  async createApiKey(projectId, options) {
+    const response = await this.client.request(
+      `/projects/${projectId}/api-keys`,
+      {
+        method: "POST",
+        body: options ?? {}
+      }
+    );
+    if (response.error) {
+      throw new Error(response.error.message);
+    }
+    return response.data ?? { apiKeyId: "", apiKey: "" };
+  }
+  /**
+   * Revoke an API key
+   */
+  async revokeApiKey(projectId, keyId) {
+    const response = await this.client.request(
+      `/projects/${projectId}/api-keys/${keyId}/revoke`,
+      {
+        method: "POST"
+      }
+    );
+    if (response.error) {
+      throw new Error(response.error.message);
+    }
+  }
+  /**
+   * Rotate an API key (revoke and create new)
+   */
+  async rotateApiKey(projectId, keyId) {
+    const response = await this.client.request(
+      `/projects/${projectId}/api-keys/${keyId}/rotate`,
+      {
+        method: "POST"
+      }
+    );
+    if (response.error) {
+      throw new Error(response.error.message);
+    }
+    return response.data ?? { apiKeyId: "", apiKey: "" };
+  }
+  // Project Settings Methods
+  /**
+   * Get project settings
+   */
+  async getSettings(projectId) {
+    const response = await this.client.request(
+      `/projects/${projectId}/settings`
+    );
+    if (response.error) {
+      throw new Error(response.error.message);
+    }
+    return response.data ?? {};
+  }
+  /**
+   * Get compute settings
+   */
+  async getComputeSettings(projectId) {
+    const response = await this.client.request(
+      `/projects/${projectId}/settings/compute`
+    );
+    if (response.error) {
+      throw new Error(response.error.message);
+    }
+    return response.data ?? {
+      tier: "starter",
+      diskSize: 1,
+      region: "us-east-1",
+      autoScaling: false,
+      maxInstances: 1
+    };
+  }
+  /**
+   * Update compute settings
+   */
+  async updateComputeSettings(projectId, settings) {
+    const response = await this.client.request(
+      `/projects/${projectId}/settings/compute`,
+      {
+        method: "PATCH",
+        body: settings
+      }
+    );
+    if (response.error) {
+      throw new Error(response.error.message);
+    }
+    return response.data ?? {};
+  }
+  /**
+   * Get API settings
+   */
+  async getApiSettings(projectId) {
+    const response = await this.client.request(
+      `/projects/${projectId}/settings/api`
+    );
+    if (response.error) {
+      throw new Error(response.error.message);
+    }
+    return response.data ?? {
+      apiVersion: "v1",
+      rateLimit: 100,
+      corsEnabled: true,
+      corsOrigins: ["*"],
+      customDomain: ""
+    };
+  }
+  /**
+   * Update API settings
+   */
+  async updateApiSettings(projectId, settings) {
+    const response = await this.client.request(
+      `/projects/${projectId}/settings/api`,
+      {
+        method: "PATCH",
+        body: settings
+      }
+    );
+    if (response.error) {
+      throw new Error(response.error.message);
+    }
+    return response.data ?? {};
+  }
+  /**
+   * Get JWT settings
+   */
+  async getJwtSettings(projectId) {
+    const response = await this.client.request(
+      `/projects/${projectId}/settings/jwt`
+    );
+    if (response.error) {
+      throw new Error(response.error.message);
+    }
+    return response.data ?? {
+      algorithm: "HS256",
+      accessTokenExpiry: 3600,
+      refreshTokenExpiry: 604800,
+      refreshTokenEnabled: true,
+      rotateOnUse: true,
+      secretHint: "********",
+      lastRotated: null
+    };
+  }
+  /**
+   * Update JWT settings
+   */
+  async updateJwtSettings(projectId, settings) {
+    const response = await this.client.request(
+      `/projects/${projectId}/settings/jwt`,
+      {
+        method: "PATCH",
+        body: settings
+      }
+    );
+    if (response.error) {
+      throw new Error(response.error.message);
+    }
+    return response.data ?? {};
+  }
+  /**
+   * Rotate JWT secret
+   */
+  async rotateJwtSecret(projectId) {
+    const response = await this.client.request(
+      `/projects/${projectId}/settings/jwt/rotate`,
+      {
+        method: "POST"
+      }
+    );
+    if (response.error) {
+      throw new Error(response.error.message);
+    }
+    return response.data ?? { secretHint: "", lastRotated: "" };
+  }
+  /**
+   * Get addons configuration
+   */
+  async getAddons(projectId) {
+    const response = await this.client.request(
+      `/projects/${projectId}/settings/addons`
+    );
+    if (response.error) {
+      throw new Error(response.error.message);
+    }
+    return response.data ?? {
+      enabledAddons: [],
+      currentTier: "free"
+    };
+  }
+  /**
+   * Update addons configuration
+   */
+  async updateAddons(projectId, enabledAddons) {
+    const response = await this.client.request(
+      `/projects/${projectId}/settings/addons`,
+      {
+        method: "PATCH",
+        body: { enabledAddons }
+      }
+    );
+    if (response.error) {
+      throw new Error(response.error.message);
+    }
+    return response.data ?? {};
+  }
+};
+
+// src/lib/apiKeys.ts
+var VaifApiKeys = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List API keys for a project
+   */
+  async list(projectId) {
+    const response = await this.client.request(
+      `/projects/${projectId}/api-keys`
+    );
+    if (response.error) {
+      throw new Error(response.error.message);
+    }
+    const keys = response.data?.keys ?? [];
+    return keys.map((key) => ({
+      ...key,
+      keyHint: key.keyHint || `vaif_${key.id.slice(0, 8)}...`,
+      permissions: key.scopes || key.permissions || ["read"]
+    }));
+  }
+  /**
+   * Create a new API key
+   */
+  async create(options) {
+    const { projectId, ...body } = options;
+    const requestBody = { ...body };
+    if (options.permissions && !options.scopes) {
+      const scopeMap = {
+        read: "crud",
+        write: "crud",
+        admin: "crud",
+        functions: "functions",
+        storage: "storage",
+        realtime: "realtime"
+      };
+      requestBody.scopes = options.permissions.map((p) => scopeMap[p] || p).filter((v, i, a) => a.indexOf(v) === i);
+    }
+    if (options.expiresIn && options.expiresIn !== "never") {
+      const durationMatch = options.expiresIn.match(/^(\d+)([dmy])$/);
+      if (durationMatch) {
+        const amount = parseInt(durationMatch[1], 10);
+        const unit = durationMatch[2];
+        const now = /* @__PURE__ */ new Date();
+        switch (unit) {
+          case "d":
+            now.setDate(now.getDate() + amount);
+            break;
+          case "m":
+            now.setMonth(now.getMonth() + amount);
+            break;
+          case "y":
+            now.setFullYear(now.getFullYear() + amount);
+            break;
+        }
+        requestBody.expiresAt = now.toISOString();
+      }
+    }
+    const response = await this.client.request(
+      `/projects/${projectId}/api-keys`,
+      {
+        method: "POST",
+        body: requestBody
+      }
+    );
+    if (response.error) {
+      throw new Error(response.error.message);
+    }
+    return {
+      id: response.data?.apiKeyId ?? "",
+      key: response.data?.apiKey ?? "",
+      name: options.name ?? null,
+      permissions: options.permissions ?? ["read"],
+      expiresAt: requestBody.expiresAt ?? null
+    };
+  }
+  /**
+   * Revoke an API key
+   */
+  async revoke(keyId, projectId) {
+    if (!projectId) {
+      throw new Error("projectId is required to revoke an API key");
+    }
+    const response = await this.client.request(
+      `/projects/${projectId}/api-keys/${keyId}/revoke`,
+      {
+        method: "POST"
+      }
+    );
+    if (response.error) {
+      throw new Error(response.error.message);
+    }
+  }
+  /**
+   * Rotate an API key
+   */
+  async rotate(keyId, projectId) {
+    const response = await this.client.request(
+      `/projects/${projectId}/api-keys/${keyId}/rotate`,
+      {
+        method: "POST"
+      }
+    );
+    if (response.error) {
+      throw new Error(response.error.message);
+    }
+    return {
+      id: response.data?.apiKeyId ?? "",
+      key: response.data?.apiKey ?? "",
+      name: null,
+      permissions: [],
+      expiresAt: null
+    };
+  }
+  /**
+   * Update an API key
+   */
+  async update(projectId, keyId, options) {
+    const response = await this.client.request(
+      `/projects/${projectId}/api-keys/${keyId}`,
+      {
+        method: "PATCH",
+        body: options
+      }
+    );
+    if (response.error) {
+      throw new Error(response.error.message);
+    }
+    return response.data?.apiKey ?? {};
+  }
+};
+
+// src/lib/integrations.ts
+var VaifIntegrations = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List integrations for a project
+   */
+  async list(projectId) {
+    const response = await this.client.request(
+      `/integrations/subscriptions/project/${projectId}`
+    );
+    if (response.error) {
+      throw new Error(response.error.message);
+    }
+    return (response.data?.subscriptions ?? []).map((sub) => ({
+      ...sub,
+      enabled: !sub.updatedAt || true
+      // Default to enabled if no explicit disabled state
+    }));
+  }
+  /**
+   * Create a new integration
+   */
+  async create(options) {
+    const response = await this.client.request(
+      "/integrations/subscriptions",
+      {
+        method: "POST",
+        body: options
+      }
+    );
+    if (response.error) {
+      throw new Error(response.error.message);
+    }
+    return response.data?.subscription ?? {};
+  }
+  /**
+   * Update an integration
+   */
+  async update(integrationId, options) {
+    const response = await this.client.request(
+      `/integrations/subscriptions/${integrationId}`,
+      {
+        method: "PATCH",
+        body: options
+      }
+    );
+    if (response.error) {
+      throw new Error(response.error.message);
+    }
+    return response.data?.subscription ?? {};
+  }
+  /**
+   * Delete an integration
+   */
+  async delete(integrationId) {
+    const response = await this.client.request(
+      `/integrations/subscriptions/${integrationId}`,
+      {
+        method: "DELETE"
+      }
+    );
+    if (response.error) {
+      throw new Error(response.error.message);
+    }
+  }
+  /**
+   * Test an integration
+   */
+  async test(integrationId) {
+    const response = await this.client.request(
+      `/integrations/subscriptions/${integrationId}/test`,
+      {
+        method: "POST"
+      }
+    );
+    if (response.error) {
+      throw new Error(response.error.message);
+    }
+  }
+  /**
+   * Get webhook deliveries for an integration
+   */
+  async getDeliveries(integrationId) {
+    const response = await this.client.request(
+      `/integrations/deliveries/subscription/${integrationId}`
+    );
+    if (response.error) {
+      throw new Error(response.error.message);
+    }
+    return response.data?.deliveries ?? [];
+  }
+  /**
+   * Get failed deliveries (DLQ) for a project
+   */
+  async getFailedDeliveries(projectId, limit) {
+    const params = {};
+    if (limit) {
+      params.limit = String(limit);
+    }
+    const response = await this.client.request(
+      `/integrations/dlq/project/${projectId}`,
+      { params }
+    );
+    if (response.error) {
+      throw new Error(response.error.message);
+    }
+    return response.data?.deliveries ?? [];
+  }
+};
+
+// src/lib/client.ts
+var DEFAULT_API_URL = "https://api.vaif.studio";
+var DEFAULT_REALTIME_URL = "wss://realtime.vaif.studio";
+var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_RETRY = {
+  maxRetries: 3,
+  retryDelay: 1e3,
+  maxRetryDelay: 3e4,
+  backoffMultiplier: 2,
+  retryOn: [429, 500, 502, 503, 504],
+  retryOnNetworkError: true
+};
+var memoryStorage = {
+  data: /* @__PURE__ */ new Map(),
+  getItem(key) {
+    return this.data.get(key) ?? null;
+  },
+  setItem(key, value) {
+    this.data.set(key, value);
+  },
+  removeItem(key) {
+    this.data.delete(key);
+  }
+};
+var browserStorage = typeof window !== "undefined" && window.localStorage ? {
+  getItem: (key) => window.localStorage.getItem(key),
+  setItem: (key, value) => window.localStorage.setItem(key, value),
+  removeItem: (key) => window.localStorage.removeItem(key)
+} : null;
+function calculateRetryDelay(attempt, config) {
+  const exponentialDelay = config.retryDelay * Math.pow(config.backoffMultiplier, attempt);
+  const cappedDelay = Math.min(exponentialDelay, config.maxRetryDelay);
+  const jitter = 0.5 + Math.random();
+  return Math.floor(cappedDelay * jitter);
+}
+function isRetryableStatus(status, config) {
+  return config.retryOn.includes(status);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function createClient(options) {
+  return new VaifClient(options);
+}
+var VaifClient = class {
+  constructor(options) {
+    this.accessToken = null;
+    const isAdminClient = options.baseUrl || options.accessToken;
+    if (!isAdminClient) {
+      if (!options.projectId) {
+        throw new VaifError("projectId is required", { code: "INVALID_CONFIG" });
+      }
+      if (!options.apiKey) {
+        throw new VaifError("apiKey is required", { code: "INVALID_CONFIG" });
+      }
+    }
+    this.config = {
+      projectId: options.projectId ?? "",
+      apiKey: options.apiKey ?? "",
+      apiKeyHeader: options.apiKeyHeader ?? "apikey",
+      apiUrl: options.baseUrl ?? options.apiUrl ?? DEFAULT_API_URL,
+      realtimeUrl: options.realtimeUrl ?? DEFAULT_REALTIME_URL,
+      timeout: options.timeout ?? DEFAULT_TIMEOUT,
+      headers: options.headers ?? {},
+      debug: options.debug ?? false,
+      autoRefreshToken: options.autoRefreshToken ?? true,
+      persistSession: options.persistSession ?? true,
+      storage: options.storage ?? browserStorage ?? memoryStorage,
+      retry: {
+        ...DEFAULT_RETRY,
+        ...options.retry,
+        retryOn: options.retry?.retryOn ?? DEFAULT_RETRY.retryOn
+      },
+      interceptors: options.interceptors ?? {}
+    };
     if (options.accessToken) {
       this.accessToken = options.accessToken;
     }
@@ -2500,124 +3558,236 @@ var VaifClient = class {
     this.functions = new VaifFunctions(this);
     this.auth = new VaifAuth(this);
     this.ai = new VaifAI(this);
+    this.schema = new VaifSchema(this);
     this.typegen = new VaifTypeGen(this);
     this.admin = new VaifAdmin(this);
+    this.projects = new VaifProjects(this);
+    this.apiKeys = new VaifApiKeys(this);
+    this.integrations = new VaifIntegrations(this);
     this.restoreSession();
   }
-  /**
-   * Get current configuration
-   */
+  /** Get current configuration */
   getConfig() {
     return this.config;
   }
-  /**
-   * Set access token for authenticated requests
-   */
+  /** Set access token for authenticated requests */
   setAccessToken(token) {
     this.accessToken = token;
   }
-  /**
-   * Get current access token
-   */
+  /** Get current access token */
   getAccessToken() {
     return this.accessToken;
   }
   /**
-   * Make an authenticated API request
+   * Make an authenticated API request with automatic retry and interceptors
+   *
+   * @param path - API path (relative to base URL)
+   * @param options - Request options (method, body, params, etc.)
+   * @returns Typed API response with data, error, status, and headers
    */
   async request(path, options = {}) {
-    const url = new URL(path, this.config.apiUrl);
-    if (options.params) {
-      Object.entries(options.params).forEach(([key, value]) => {
-        if (value !== void 0) {
-          url.searchParams.set(key, String(value));
+    const { retry, interceptors } = this.config;
+    for (let attempt = 0; attempt <= retry.maxRetries; attempt++) {
+      const startTime = Date.now();
+      const url = new URL(path, this.config.apiUrl);
+      if (options.params) {
+        Object.entries(options.params).forEach(([key, value]) => {
+          if (value !== void 0) {
+            url.searchParams.set(key, String(value));
+          }
+        });
+      }
+      const headers = {
+        "Content-Type": "application/json",
+        ...this.config.headers,
+        ...options.headers
+      };
+      if (this.config.projectId) {
+        headers["X-Project-ID"] = this.config.projectId;
+      }
+      if (this.config.apiKey) {
+        headers[this.config.apiKeyHeader] = this.config.apiKey;
+      }
+      if (this.accessToken) {
+        headers.Authorization = `Bearer ${this.accessToken}`;
+      }
+      let requestContext = {
+        url: url.toString(),
+        path,
+        method: options.method ?? "GET",
+        headers: { ...headers },
+        body: options.body && options.method !== "GET" ? JSON.stringify(options.body) : void 0,
+        attempt
+      };
+      if (interceptors.onRequest) {
+        try {
+          const modified = await interceptors.onRequest(requestContext);
+          if (modified) {
+            requestContext = modified;
+          }
+        } catch {
         }
-      });
-    }
-    const headers = {
-      "Content-Type": "application/json",
-      ...this.config.headers,
-      ...options.headers
-    };
-    if (this.config.projectId) {
-      headers["X-Project-ID"] = this.config.projectId;
-    }
-    if (this.config.apiKey) {
-      headers[this.config.apiKeyHeader] = this.config.apiKey;
-    }
-    if (this.accessToken) {
-      headers.Authorization = `Bearer ${this.accessToken}`;
-    }
-    const fetchOptions = {
-      method: options.method ?? "GET",
-      headers,
-      signal: options.signal
-    };
-    if (options.body && options.method !== "GET") {
-      fetchOptions.body = JSON.stringify(options.body);
-    }
-    const timeoutMs = options.timeout ?? this.config.timeout;
-    const timeoutController = new AbortController();
-    const timeoutId = setTimeout(() => timeoutController.abort(), timeoutMs);
-    if (options.signal) {
-      options.signal.addEventListener("abort", () => timeoutController.abort());
-    }
-    fetchOptions.signal = timeoutController.signal;
-    try {
-      if (this.config.debug) {
-        console.log(`[VAIF] ${options.method ?? "GET"} ${url.toString()}`);
       }
-      const response = await fetch(url.toString(), fetchOptions);
-      clearTimeout(timeoutId);
-      const contentType = response.headers.get("content-type");
-      let data = null;
-      let error = null;
-      if (contentType?.includes("application/json")) {
-        const json = await response.json();
-        if (response.ok) {
-          data = json;
-        } else {
+      const fetchOptions = {
+        method: requestContext.method,
+        headers: requestContext.headers,
+        signal: options.signal
+      };
+      if (requestContext.body) {
+        fetchOptions.body = requestContext.body;
+      }
+      const timeoutMs = options.timeout ?? this.config.timeout;
+      const timeoutController = new AbortController();
+      const timeoutId = setTimeout(() => timeoutController.abort(), timeoutMs);
+      if (options.signal) {
+        options.signal.addEventListener("abort", () => timeoutController.abort());
+      }
+      fetchOptions.signal = timeoutController.signal;
+      try {
+        if (this.config.debug) {
+          console.log(`[VAIF] ${requestContext.method} ${requestContext.url} (attempt ${attempt + 1})`);
+        }
+        const response = await fetch(requestContext.url, fetchOptions);
+        clearTimeout(timeoutId);
+        const durationMs = Date.now() - startTime;
+        const contentType = response.headers.get("content-type");
+        let data = null;
+        let error = null;
+        if (contentType?.includes("application/json")) {
+          const json = await response.json();
+          if (response.ok) {
+            data = json;
+          } else {
+            error = {
+              message: json.message ?? json.error ?? "Request failed",
+              code: json.code,
+              status: response.status,
+              details: json.details,
+              requestId: response.headers.get("x-request-id") ?? void 0
+            };
+          }
+        } else if (!response.ok) {
           error = {
-            message: json.message ?? json.error ?? "Request failed",
-            code: json.code,
-            status: response.status,
-            details: json.details,
-            requestId: response.headers.get("x-request-id") ?? void 0
+            message: `Request failed with status ${response.status}`,
+            status: response.status
           };
         }
-      } else if (!response.ok) {
-        error = {
-          message: `Request failed with status ${response.status}`,
-          status: response.status
+        const responseHeaders = {};
+        response.headers.forEach((value, key) => {
+          responseHeaders[key] = value;
+        });
+        if (error && attempt < retry.maxRetries && isRetryableStatus(response.status, retry)) {
+          if (interceptors.onError) {
+            try {
+              await interceptors.onError({
+                request: requestContext,
+                error: new VaifError(error.message, {
+                  code: error.code ?? "REQUEST_ERROR",
+                  statusCode: response.status
+                }),
+                durationMs,
+                willRetry: true
+              });
+            } catch {
+            }
+          }
+          const delay = calculateRetryDelay(attempt, retry);
+          if (this.config.debug) {
+            console.log(`[VAIF] Retrying in ${delay}ms (attempt ${attempt + 2}/${retry.maxRetries + 1})`);
+          }
+          await sleep(delay);
+          continue;
+        }
+        if (!error && interceptors.onResponse) {
+          try {
+            await interceptors.onResponse({
+              request: requestContext,
+              data,
+              status: response.status,
+              headers: responseHeaders,
+              durationMs
+            });
+          } catch {
+          }
+        }
+        if (error && interceptors.onError) {
+          try {
+            await interceptors.onError({
+              request: requestContext,
+              error: new VaifError(error.message, {
+                code: error.code ?? "REQUEST_ERROR",
+                statusCode: response.status
+              }),
+              durationMs,
+              willRetry: false
+            });
+          } catch {
+          }
+        }
+        return {
+          data,
+          error,
+          status: response.status,
+          headers: responseHeaders
+        };
+      } catch (err) {
+        clearTimeout(timeoutId);
+        const durationMs = Date.now() - startTime;
+        const isTimeout = err instanceof Error && err.name === "AbortError";
+        const isNetworkError = !isTimeout;
+        if (isNetworkError && retry.retryOnNetworkError && attempt < retry.maxRetries) {
+          if (interceptors.onError) {
+            try {
+              await interceptors.onError({
+                request: requestContext,
+                error: err instanceof Error ? err : new Error(String(err)),
+                durationMs,
+                willRetry: true
+              });
+            } catch {
+            }
+          }
+          const delay = calculateRetryDelay(attempt, retry);
+          if (this.config.debug) {
+            console.log(`[VAIF] Network error, retrying in ${delay}ms`);
+          }
+          await sleep(delay);
+          continue;
+        }
+        const error = {
+          message: err instanceof Error ? isTimeout ? "Request timed out" : err.message : "Unknown error",
+          code: isTimeout ? "TIMEOUT" : "NETWORK_ERROR"
+        };
+        if (interceptors.onError) {
+          try {
+            await interceptors.onError({
+              request: requestContext,
+              error: isTimeout ? new VaifTimeoutError("Request timed out", timeoutMs) : new VaifNetworkError(
+                err instanceof Error ? err.message : "Network error",
+                err instanceof Error ? err : void 0
+              ),
+              durationMs,
+              willRetry: false
+            });
+          } catch {
+          }
+        }
+        return {
+          data: null,
+          error,
+          status: 0,
+          headers: {}
         };
       }
-      const responseHeaders = {};
-      response.headers.forEach((value, key) => {
-        responseHeaders[key] = value;
-      });
-      return {
-        data,
-        error,
-        status: response.status,
-        headers: responseHeaders
-      };
-    } catch (err) {
-      clearTimeout(timeoutId);
-      const error = {
-        message: err instanceof Error ? err.name === "AbortError" ? "Request timed out" : err.message : "Unknown error",
-        code: err instanceof Error && err.name === "AbortError" ? "TIMEOUT" : "NETWORK_ERROR"
-      };
-      return {
-        data: null,
-        error,
-        status: 0,
-        headers: {}
-      };
     }
+    return {
+      data: null,
+      error: { message: "Max retries exceeded", code: "MAX_RETRIES" },
+      status: 0,
+      headers: {}
+    };
   }
-  /**
-   * Restore session from storage
-   */
+  /** Restore session from storage */
   async restoreSession() {
     if (!this.config.persistSession) return;
     try {
@@ -2633,27 +3803,46 @@ var VaifClient = class {
     } catch {
     }
   }
-  /**
-   * Log debug messages
-   */
+  /** Log debug messages */
   debug(...args) {
     if (this.config.debug) {
       console.log("[VAIF]", ...args);
     }
   }
 };
-export {
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
   RealtimeChannel,
   VaifAI,
   VaifAdmin,
+  VaifApiKeys,
   VaifAuth,
+  VaifAuthError,
   VaifClient,
+  VaifConflictError,
   VaifDatabase,
+  VaifError,
   VaifFunctions,
+  VaifIntegrations,
+  VaifNetworkError,
+  VaifNotFoundError,
+  VaifProjects,
+  VaifRateLimitError,
   VaifRealtime,
+  VaifSchema,
   VaifStorage,
+  VaifTimeoutError,
   VaifTypeGen,
+  VaifValidationError,
   createClient,
   createTypeGen,
-  createClient as createVaifClient
-};
+  createVaifClient,
+  isVaifAuthError,
+  isVaifConflictError,
+  isVaifError,
+  isVaifNetworkError,
+  isVaifNotFoundError,
+  isVaifRateLimitError,
+  isVaifTimeoutError,
+  isVaifValidationError
+});