@aerostack/sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1169 @@
+// src/client-errors.ts
+var ClientErrorCode = /* @__PURE__ */ ((ClientErrorCode2) => {
+  ClientErrorCode2["AUTH_INVALID_CREDENTIALS"] = "AUTH_INVALID_CREDENTIALS";
+  ClientErrorCode2["AUTH_USER_EXISTS"] = "AUTH_USER_EXISTS";
+  ClientErrorCode2["AUTH_EMAIL_NOT_VERIFIED"] = "AUTH_EMAIL_NOT_VERIFIED";
+  ClientErrorCode2["AUTH_TOKEN_EXPIRED"] = "AUTH_TOKEN_EXPIRED";
+  ClientErrorCode2["AUTH_TOKEN_INVALID"] = "AUTH_TOKEN_INVALID";
+  ClientErrorCode2["AUTH_OTP_EXPIRED"] = "AUTH_OTP_EXPIRED";
+  ClientErrorCode2["AUTH_OTP_INVALID"] = "AUTH_OTP_INVALID";
+  ClientErrorCode2["AUTH_PASSWORD_WEAK"] = "AUTH_PASSWORD_WEAK";
+  ClientErrorCode2["AUTH_RESET_TOKEN_INVALID"] = "AUTH_RESET_TOKEN_INVALID";
+  ClientErrorCode2["NETWORK_ERROR"] = "NETWORK_ERROR";
+  ClientErrorCode2["NETWORK_TIMEOUT"] = "NETWORK_TIMEOUT";
+  ClientErrorCode2["VALIDATION_ERROR"] = "VALIDATION_ERROR";
+  ClientErrorCode2["REQUEST_FAILED"] = "REQUEST_FAILED";
+  ClientErrorCode2["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
+  return ClientErrorCode2;
+})(ClientErrorCode || {});
+var ClientError = class _ClientError extends Error {
+  constructor(code, message, details, statusCode) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.statusCode = statusCode;
+    this.name = "ClientError";
+    Object.setPrototypeOf(this, _ClientError.prototype);
+  }
+  /**
+   * Check if this is an authentication error
+   */
+  isAuthError() {
+    return this.code.toString().startsWith("AUTH_");
+  }
+  /**
+   * Check if this is a network error
+   */
+  isNetworkError() {
+    return this.code === "NETWORK_ERROR" /* NETWORK_ERROR */ || this.code === "NETWORK_TIMEOUT" /* NETWORK_TIMEOUT */;
+  }
+  /**
+   * Check if this is a validation error
+   */
+  isValidationError() {
+    return this.code === "VALIDATION_ERROR" /* VALIDATION_ERROR */;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      details: this.details,
+      statusCode: this.statusCode
+    };
+  }
+};
+var AuthenticationError = class _AuthenticationError extends ClientError {
+  constructor(code, message, details, statusCode) {
+    super(code, message, details, statusCode);
+    this.name = "AuthenticationError";
+    Object.setPrototypeOf(this, _AuthenticationError.prototype);
+  }
+};
+var ValidationError = class _ValidationError extends ClientError {
+  constructor(message, field, suggestion) {
+    super(
+      "VALIDATION_ERROR" /* VALIDATION_ERROR */,
+      message,
+      { field, suggestion },
+      400
+    );
+    this.name = "ValidationError";
+    Object.setPrototypeOf(this, _ValidationError.prototype);
+  }
+};
+var NetworkError = class _NetworkError extends ClientError {
+  constructor(message, suggestion) {
+    super(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      message,
+      { suggestion }
+    );
+    this.name = "NetworkError";
+    Object.setPrototypeOf(this, _NetworkError.prototype);
+  }
+};
+
+// src/client.ts
+var AerostackClient = class {
+  projectSlug;
+  baseUrl;
+  constructor(config) {
+    this.projectSlug = config.projectSlug;
+    this.baseUrl = config.baseUrl || "https://api.aerostack.app";
+  }
+  /**
+   * Authentication operations
+   */
+  get auth() {
+    return {
+      /**
+       * Register a new user
+       */
+      register: async (data) => {
+        if (!data.email || !data.email.includes("@")) {
+          throw new ValidationError("Invalid email address", "email", "Provide a valid email address");
+        }
+        if (!data.password || data.password.length < 8) {
+          throw new ValidationError(
+            "Password must be at least 8 characters",
+            "password",
+            "Use a stronger password with minimum 8 characters"
+          );
+        }
+        return this.request("/auth/register", "POST", data);
+      },
+      /**
+       * Login with email and password
+       */
+      login: async (email, password) => {
+        if (!email || !password) {
+          throw new ValidationError("Email and password are required", "email");
+        }
+        return this.request("/auth/login", "POST", { email, password });
+      },
+      /**
+       * Send OTP code to email
+       */
+      sendOTP: async (email) => {
+        if (!email || !email.includes("@")) {
+          throw new ValidationError("Invalid email address", "email");
+        }
+        return this.request("/auth/otp/send", "POST", { email });
+      },
+      /**
+       * Verify OTP code and login
+       */
+      verifyOTP: async (email, code) => {
+        if (!email || !code) {
+          throw new ValidationError("Email and code are required");
+        }
+        if (code.length !== 6 || !/^\d+$/.test(code)) {
+          throw new ValidationError("OTP code must be 6 digits", "code");
+        }
+        return this.request("/auth/otp/verify", "POST", { email, code });
+      },
+      /**
+       * Verify email with token
+       */
+      verifyEmail: async (token) => {
+        if (!token) {
+          throw new ValidationError("Verification token is required", "token");
+        }
+        return this.request(`/auth/verify-email?token=${token}`, "GET");
+      },
+      /**
+       * Request password reset email
+       */
+      requestPasswordReset: async (email) => {
+        if (!email || !email.includes("@")) {
+          throw new ValidationError("Invalid email address", "email");
+        }
+        return this.request("/auth/password-reset/request", "POST", { email });
+      },
+      /**
+       * Reset password with token
+       */
+      resetPassword: async (token, newPassword) => {
+        if (!token) {
+          throw new ValidationError("Reset token is required", "token");
+        }
+        if (!newPassword || newPassword.length < 8) {
+          throw new ValidationError(
+            "Password must be at least 8 characters",
+            "password",
+            "Use a stronger password"
+          );
+        }
+        return this.request("/auth/password-reset/confirm", "POST", { token, newPassword });
+      },
+      /**
+       * Refresh access token using refresh token
+       */
+      refreshToken: async (refreshToken) => {
+        if (!refreshToken) {
+          throw new ValidationError("Refresh token is required", "refreshToken");
+        }
+        return this.request("/auth/refresh", "POST", { refreshToken });
+      },
+      /**
+       * Logout and invalidate tokens
+       */
+      logout: async (token) => {
+        return this.request("/auth/logout", "POST", {}, token);
+      },
+      /**
+       * Get current user profile
+       */
+      getCurrentUser: async (token) => {
+        if (!token) {
+          throw new AuthenticationError(
+            "AUTH_TOKEN_INVALID" /* AUTH_TOKEN_INVALID */,
+            "Authentication token is required",
+            { suggestion: "Please login first" }
+          );
+        }
+        const response = await this.request("/auth/me", "GET", void 0, token);
+        return response.user;
+      },
+      /**
+       * Update user profile
+       */
+      updateProfile: async (token, updates) => {
+        if (!token) {
+          throw new AuthenticationError(
+            "AUTH_TOKEN_INVALID" /* AUTH_TOKEN_INVALID */,
+            "Authentication token is required",
+            { suggestion: "Please login first" }
+          );
+        }
+        const response = await this.request("/auth/me", "PATCH", updates, token);
+        return response.user;
+      }
+    };
+  }
+  /**
+   * Make HTTP request with comprehensive error handling
+   */
+  async request(path, method, body, token) {
+    const url = `${this.baseUrl}/api/v1/public/projects/${this.projectSlug}${path}`;
+    const options = {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        ...token && { Authorization: `Bearer ${token}` }
+      }
+    };
+    if (body) {
+      options.body = JSON.stringify(body);
+    }
+    try {
+      const response = await fetch(url, options);
+      const data = await response.json();
+      if (!response.ok) {
+        const errorCode = this.mapErrorCode(data.code, response.status);
+        const errorMessage = data.message || data.error || "Request failed";
+        throw new ClientError(
+          errorCode,
+          errorMessage,
+          {
+            suggestion: this.getSuggestion(errorCode, data),
+            field: data.field
+          },
+          response.status
+        );
+      }
+      return data;
+    } catch (err) {
+      if (err instanceof ClientError) {
+        throw err;
+      }
+      if (err.name === "TypeError" && err.message.includes("fetch")) {
+        throw new NetworkError("Network request failed", "Check your internet connection");
+      }
+      if (err.name === "AbortError") {
+        throw new NetworkError("Request timeout", "The request took too long. Please try again");
+      }
+      throw new ClientError(
+        "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+        err.message || "An unexpected error occurred",
+        {
+          suggestion: "Please try again or contact support"
+        }
+      );
+    }
+  }
+  /**
+   * Map API error codes to client error codes
+   */
+  mapErrorCode(apiCode, statusCode) {
+    if (apiCode) {
+      if (Object.values(ClientErrorCode).includes(apiCode)) {
+        return apiCode;
+      }
+    }
+    switch (statusCode) {
+      case 401:
+        return "AUTH_INVALID_CREDENTIALS" /* AUTH_INVALID_CREDENTIALS */;
+      case 409:
+        return "AUTH_USER_EXISTS" /* AUTH_USER_EXISTS */;
+      case 400:
+        return "VALIDATION_ERROR" /* VALIDATION_ERROR */;
+      case 403:
+        return "AUTH_TOKEN_INVALID" /* AUTH_TOKEN_INVALID */;
+      default:
+        return "REQUEST_FAILED" /* REQUEST_FAILED */;
+    }
+  }
+  /**
+   * Get helpful suggestion based on error code
+   */
+  getSuggestion(errorCode, data) {
+    switch (errorCode) {
+      case "AUTH_INVALID_CREDENTIALS" /* AUTH_INVALID_CREDENTIALS */:
+        return "Double-check your email and password";
+      case "AUTH_USER_EXISTS" /* AUTH_USER_EXISTS */:
+        return "Try logging in instead, or use password reset if you forgot your password";
+      case "AUTH_EMAIL_NOT_VERIFIED" /* AUTH_EMAIL_NOT_VERIFIED */:
+        return "Check your email for verification link";
+      case "AUTH_TOKEN_EXPIRED" /* AUTH_TOKEN_EXPIRED */:
+        return "Your session has expired. Please login again";
+      case "AUTH_OTP_EXPIRED" /* AUTH_OTP_EXPIRED */:
+        return "Request a new OTP code";
+      case "AUTH_OTP_INVALID" /* AUTH_OTP_INVALID */:
+        return "Check the code and try again, or request a new one";
+      case "AUTH_PASSWORD_WEAK" /* AUTH_PASSWORD_WEAK */:
+        return "Use at least 8 characters with a mix of letters, numbers, and symbols";
+      case "NETWORK_ERROR" /* NETWORK_ERROR */:
+        return "Check your internet connection and try again";
+      default:
+        return data?.details?.suggestion || "Please try again or contact support";
+    }
+  }
+};
+
+// src/server.ts
+import { Pool } from "@neondatabase/serverless";
+
+// src/server-errors.ts
+var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
+  ErrorCode2["DB_CONNECTION_FAILED"] = "DB_CONNECTION_FAILED";
+  ErrorCode2["DB_QUERY_FAILED"] = "DB_QUERY_FAILED";
+  ErrorCode2["DB_TABLE_NOT_FOUND"] = "DB_TABLE_NOT_FOUND";
+  ErrorCode2["DB_COLUMN_NOT_FOUND"] = "DB_COLUMN_NOT_FOUND";
+  ErrorCode2["DB_AUTH_FAILED"] = "DB_AUTH_FAILED";
+  ErrorCode2["DB_MIGRATION_FAILED"] = "DB_MIGRATION_FAILED";
+  ErrorCode2["DB_TRANSACTION_FAILED"] = "DB_TRANSACTION_FAILED";
+  ErrorCode2["CACHE_GET_FAILED"] = "CACHE_GET_FAILED";
+  ErrorCode2["CACHE_SET_FAILED"] = "CACHE_SET_FAILED";
+  ErrorCode2["CACHE_DELETE_FAILED"] = "CACHE_DELETE_FAILED";
+  ErrorCode2["CACHE_NOT_CONFIGURED"] = "CACHE_NOT_CONFIGURED";
+  ErrorCode2["QUEUE_ENQUEUE_FAILED"] = "QUEUE_ENQUEUE_FAILED";
+  ErrorCode2["QUEUE_NOT_CONFIGURED"] = "QUEUE_NOT_CONFIGURED";
+  ErrorCode2["QUEUE_JOB_NOT_FOUND"] = "QUEUE_JOB_NOT_FOUND";
+  ErrorCode2["STORAGE_UPLOAD_FAILED"] = "STORAGE_UPLOAD_FAILED";
+  ErrorCode2["STORAGE_DELETE_FAILED"] = "STORAGE_DELETE_FAILED";
+  ErrorCode2["STORAGE_NOT_CONFIGURED"] = "STORAGE_NOT_CONFIGURED";
+  ErrorCode2["STORAGE_FILE_TOO_LARGE"] = "STORAGE_FILE_TOO_LARGE";
+  ErrorCode2["AI_REQUEST_FAILED"] = "AI_REQUEST_FAILED";
+  ErrorCode2["AI_NOT_CONFIGURED"] = "AI_NOT_CONFIGURED";
+  ErrorCode2["AI_RATE_LIMIT"] = "AI_RATE_LIMIT";
+  ErrorCode2["SERVICE_INVOKE_FAILED"] = "SERVICE_INVOKE_FAILED";
+  ErrorCode2["SERVICE_NOT_FOUND"] = "SERVICE_NOT_FOUND";
+  ErrorCode2["CONFIGURATION_ERROR"] = "CONFIGURATION_ERROR";
+  ErrorCode2["VALIDATION_ERROR"] = "VALIDATION_ERROR";
+  ErrorCode2["INTERNAL_ERROR"] = "INTERNAL_ERROR";
+  return ErrorCode2;
+})(ErrorCode || {});
+var ServerError = class _ServerError extends Error {
+  constructor(code, message, details, context) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.context = context;
+    this.name = "ServerError";
+    Object.setPrototypeOf(this, _ServerError.prototype);
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      details: this.details,
+      context: this.context
+    };
+  }
+};
+var DatabaseError = class _DatabaseError extends ServerError {
+  constructor(code, message, details, context) {
+    super(code, message, details, context);
+    this.name = "DatabaseError";
+    Object.setPrototypeOf(this, _DatabaseError.prototype);
+  }
+  /**
+   * Create error from Postgres error
+   */
+  static fromPostgresError(err, context) {
+    switch (err.code) {
+      case "42P01":
+        return new _DatabaseError(
+          "DB_TABLE_NOT_FOUND" /* DB_TABLE_NOT_FOUND */,
+          `Table does not exist: ${err.table || "unknown"}`,
+          {
+            suggestion: "Run migrations first: aerostack db migrate apply",
+            recoveryAction: "CREATE_TABLE",
+            cause: err.message
+          },
+          context
+        );
+      case "42703":
+        return new _DatabaseError(
+          "DB_COLUMN_NOT_FOUND" /* DB_COLUMN_NOT_FOUND */,
+          `Column does not exist: ${err.column || "unknown"}`,
+          {
+            suggestion: "Check your schema or run latest migrations",
+            recoveryAction: "ALTER_TABLE",
+            cause: err.message
+          },
+          context
+        );
+      case "28P01":
+      // invalid_password
+      case "28000":
+        return new _DatabaseError(
+          "DB_AUTH_FAILED" /* DB_AUTH_FAILED */,
+          "Database authentication failed",
+          {
+            suggestion: "Check your DATABASE_URL environment variable",
+            recoveryAction: "UPDATE_CREDENTIALS",
+            cause: err.message
+          },
+          context
+        );
+      case "08006":
+      // connection_failure
+      case "08003":
+        return new _DatabaseError(
+          "DB_CONNECTION_FAILED" /* DB_CONNECTION_FAILED */,
+          "Failed to connect to database",
+          {
+            suggestion: "Verify your database connection string and network connectivity",
+            recoveryAction: "CHECK_CONNECTION",
+            cause: err.message
+          },
+          context
+        );
+      default:
+        return new _DatabaseError(
+          "DB_QUERY_FAILED" /* DB_QUERY_FAILED */,
+          err.message || "Database query failed",
+          {
+            suggestion: "Check your query syntax and parameters",
+            cause: err.code ? `Postgres error ${err.code}` : void 0
+          },
+          context
+        );
+    }
+  }
+  /**
+   * Create error from D1 error
+   */
+  static fromD1Error(err, context) {
+    const message = err.message || "D1 query failed";
+    if (message.includes("no such table")) {
+      return new _DatabaseError(
+        "DB_TABLE_NOT_FOUND" /* DB_TABLE_NOT_FOUND */,
+        message,
+        {
+          suggestion: "Run D1 migrations: aerostack db migrate apply",
+          recoveryAction: "CREATE_TABLE",
+          cause: err.message
+        },
+        context
+      );
+    }
+    if (message.includes("no such column")) {
+      return new _DatabaseError(
+        "DB_COLUMN_NOT_FOUND" /* DB_COLUMN_NOT_FOUND */,
+        message,
+        {
+          suggestion: "Check your schema or update migrations",
+          recoveryAction: "ALTER_TABLE",
+          cause: err.message
+        },
+        context
+      );
+    }
+    return new _DatabaseError(
+      "DB_QUERY_FAILED" /* DB_QUERY_FAILED */,
+      message,
+      {
+        suggestion: "Check your SQL syntax and D1 configuration",
+        cause: err.message
+      },
+      context
+    );
+  }
+};
+var CacheError = class _CacheError extends ServerError {
+  constructor(code, message, details, context) {
+    super(code, message, details, context);
+    this.name = "CacheError";
+    Object.setPrototypeOf(this, _CacheError.prototype);
+  }
+};
+var QueueError = class _QueueError extends ServerError {
+  constructor(code, message, details, context) {
+    super(code, message, details, context);
+    this.name = "QueueError";
+    Object.setPrototypeOf(this, _QueueError.prototype);
+  }
+};
+var StorageError = class _StorageError extends ServerError {
+  constructor(code, message, details, context) {
+    super(code, message, details, context);
+    this.name = "StorageError";
+    Object.setPrototypeOf(this, _StorageError.prototype);
+  }
+};
+var AIError = class _AIError extends ServerError {
+  constructor(code, message, details, context) {
+    super(code, message, details, context);
+    this.name = "AIError";
+    Object.setPrototypeOf(this, _AIError.prototype);
+  }
+};
+var ServiceError = class _ServiceError extends ServerError {
+  constructor(code, message, details, context) {
+    super(code, message, details, context);
+    this.name = "ServiceError";
+    Object.setPrototypeOf(this, _ServiceError.prototype);
+  }
+};
+
+// src/server.ts
+var AerostackServer = class {
+  pgPool;
+  _d1;
+  _kv;
+  _queue;
+  _storage;
+  _ai;
+  _dispatcher;
+  routingRules;
+  env;
+  constructor(env, options = {}) {
+    this.env = env;
+    this._d1 = env.DB;
+    this._kv = env.CACHE;
+    this._queue = env.QUEUE;
+    this._storage = env.STORAGE;
+    this._ai = env.AI;
+    this._dispatcher = env.DISPATCHER;
+    this.routingRules = options.routing || { tables: {} };
+    const pgConnStr = this.findPostgresConnStr(env);
+    if (pgConnStr) {
+      this.pgPool = new Pool({ connectionString: pgConnStr });
+    }
+  }
+  /**
+   * Database operations with intelligent routing between D1 and Postgres
+   */
+  get db() {
+    return {
+      /**
+       * Execute a SQL query with automatic routing
+       */
+      query: async (sql, params = []) => {
+        return this.routeQuery(sql, params);
+      },
+      /**
+       * Get database schema information
+       */
+      getSchema: async (binding) => {
+        if (binding) {
+          if (this.pgPool && binding.toLowerCase().includes("postgres")) {
+            return this.introspectPostgres();
+          }
+          if (this._d1) {
+            return this.introspectD1();
+          }
+        }
+        if (this._d1) {
+          return this.introspectD1();
+        }
+        if (this.pgPool) {
+          return this.introspectPostgres();
+        }
+        throw new DatabaseError(
+          "DB_CONNECTION_FAILED" /* DB_CONNECTION_FAILED */,
+          "No database connection available",
+          {
+            suggestion: "Configure DB or Postgres connection in aerostack.toml"
+          }
+        );
+      },
+      /**
+       * Execute multiple queries in a batch
+       */
+      batch: async (queries) => {
+        const results = [];
+        const errors = [];
+        let success = true;
+        for (let i = 0; i < queries.length; i++) {
+          try {
+            const result = await this.routeQuery(queries[i].sql, queries[i].params || []);
+            results.push(result);
+          } catch (error) {
+            success = false;
+            errors.push({ index: i, error });
+            results.push({
+              results: [],
+              success: false,
+              meta: { target: "d1" }
+            });
+          }
+        }
+        return { results, success, errors: errors.length > 0 ? errors : void 0 };
+      }
+    };
+  }
+  /**
+   * KV Cache operations
+   */
+  get cache() {
+    return {
+      /**
+       * Get value from cache
+       */
+      get: async (key, options) => {
+        if (!this._kv) {
+          throw new CacheError(
+            "CACHE_NOT_CONFIGURED" /* CACHE_NOT_CONFIGURED */,
+            "KV cache not configured",
+            {
+              suggestion: "Add [[kv_namespaces]] binding to aerostack.toml"
+            }
+          );
+        }
+        try {
+          const type = options?.type || "json";
+          const value = type === "json" ? await this._kv.get(key, "json") : type === "text" ? await this._kv.get(key, "text") : type === "arrayBuffer" ? await this._kv.get(key, "arrayBuffer") : await this._kv.get(key, "stream");
+          return value;
+        } catch (err) {
+          throw new CacheError(
+            "CACHE_GET_FAILED" /* CACHE_GET_FAILED */,
+            `Failed to get cache key: ${key}`,
+            {
+              suggestion: "Check key format and KV namespace binding",
+              cause: err.message
+            },
+            { key }
+          );
+        }
+      },
+      /**
+       * Set value in cache
+       */
+      set: async (key, value, options) => {
+        if (!this._kv) {
+          throw new CacheError(
+            "CACHE_NOT_CONFIGURED" /* CACHE_NOT_CONFIGURED */,
+            "KV cache not configured",
+            {
+              suggestion: "Add [[kv_namespaces]] binding to aerostack.toml"
+            }
+          );
+        }
+        try {
+          const ttl = options?.ttl || options?.expirationTtl;
+          await this._kv.put(key, JSON.stringify(value), ttl ? { expirationTtl: ttl } : void 0);
+        } catch (err) {
+          throw new CacheError(
+            "CACHE_SET_FAILED" /* CACHE_SET_FAILED */,
+            `Failed to set cache key: ${key}`,
+            {
+              suggestion: "Check value serialization and KV limits (25MB)",
+              cause: err.message
+            },
+            { key, value }
+          );
+        }
+      },
+      /**
+       * Delete value from cache
+       */
+      delete: async (key) => {
+        if (!this._kv) {
+          throw new CacheError(
+            "CACHE_NOT_CONFIGURED" /* CACHE_NOT_CONFIGURED */,
+            "KV cache not configured",
+            {
+              suggestion: "Add [[kv_namespaces]] binding to aerostack.toml"
+            }
+          );
+        }
+        try {
+          await this._kv.delete(key);
+        } catch (err) {
+          throw new CacheError(
+            "CACHE_DELETE_FAILED" /* CACHE_DELETE_FAILED */,
+            `Failed to delete cache key: ${key}`,
+            {
+              cause: err.message
+            },
+            { key }
+          );
+        }
+      },
+      /**
+       * Check if key exists in cache
+       */
+      exists: async (key) => {
+        if (!this._kv) {
+          return false;
+        }
+        try {
+          const value = await this._kv.get(key);
+          return value !== null;
+        } catch {
+          return false;
+        }
+      }
+    };
+  }
+  /**
+   * Queue operations for background jobs
+   */
+  get queue() {
+    return {
+      /**
+       * Add job to queue
+       */
+      enqueue: async (job) => {
+        if (!this._queue) {
+          throw new QueueError(
+            "QUEUE_NOT_CONFIGURED" /* QUEUE_NOT_CONFIGURED */,
+            "Queue not configured",
+            {
+              suggestion: "Add [[queues]] binding to aerostack.toml"
+            }
+          );
+        }
+        try {
+          const message = {
+            type: job.type,
+            data: job.data,
+            queuedAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          await this._queue.send(message, {
+            delaySeconds: job.delay
+          });
+          const jobId = `job_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+          return {
+            jobId,
+            status: "queued",
+            queuedAt: /* @__PURE__ */ new Date()
+          };
+        } catch (err) {
+          throw new QueueError(
+            "QUEUE_ENQUEUE_FAILED" /* QUEUE_ENQUEUE_FAILED */,
+            "Failed to enqueue job",
+            {
+              suggestion: "Check queue binding and message size limits",
+              cause: err.message
+            },
+            { job }
+          );
+        }
+      }
+    };
+  }
+  /**
+   * R2 Storage operations
+   */
+  get storage() {
+    return {
+      /**
+       * Upload file to R2 storage
+       */
+      upload: async (file, key, options) => {
+        if (!this._storage) {
+          throw new StorageError(
+            "STORAGE_NOT_CONFIGURED" /* STORAGE_NOT_CONFIGURED */,
+            "R2 storage not configured",
+            {
+              suggestion: "Add [[r2_buckets]] binding to aerostack.toml"
+            }
+          );
+        }
+        try {
+          await this._storage.put(key, file, {
+            httpMetadata: {
+              contentType: options?.contentType,
+              cacheControl: options?.cacheControl
+            },
+            customMetadata: options?.metadata
+          });
+          const obj = await this._storage.get(key);
+          const size = obj?.size || 0;
+          return {
+            key,
+            url: `https://${this.env.STORAGE_PUBLIC_URL || "storage.aerostack.ai"}/${key}`,
+            size,
+            contentType: options?.contentType || "application/octet-stream"
+          };
+        } catch (err) {
+          throw new StorageError(
+            "STORAGE_UPLOAD_FAILED" /* STORAGE_UPLOAD_FAILED */,
+            `Failed to upload file: ${key}`,
+            {
+              suggestion: "Check R2 bucket binding and file size limits",
+              cause: err.message
+            },
+            { key }
+          );
+        }
+      },
+      /**
+       * Get presigned URL for object
+       */
+      getUrl: async (key, options) => {
+        if (!this._storage) {
+          throw new StorageError(
+            "STORAGE_NOT_CONFIGURED" /* STORAGE_NOT_CONFIGURED */,
+            "R2 storage not configured",
+            {
+              suggestion: "Add [[r2_buckets]] binding to aerostack.toml"
+            }
+          );
+        }
+        return `https://${this.env.STORAGE_PUBLIC_URL || "storage.aerostack.ai"}/${key}`;
+      },
+      /**
+       * Delete object from storage
+       */
+      delete: async (key) => {
+        if (!this._storage) {
+          throw new StorageError(
+            "STORAGE_NOT_CONFIGURED" /* STORAGE_NOT_CONFIGURED */,
+            "R2 storage not configured",
+            {
+              suggestion: "Add [[r2_buckets]] binding to aerostack.toml"
+            }
+          );
+        }
+        try {
+          await this._storage.delete(key);
+        } catch (err) {
+          throw new StorageError(
+            "STORAGE_DELETE_FAILED" /* STORAGE_DELETE_FAILED */,
+            `Failed to delete file: ${key}`,
+            {
+              cause: err.message
+            },
+            { key }
+          );
+        }
+      },
+      /**
+       * List objects in storage
+       */
+      list: async (prefix) => {
+        if (!this._storage) {
+          throw new StorageError(
+            "STORAGE_NOT_CONFIGURED" /* STORAGE_NOT_CONFIGURED */,
+            "R2 storage not configured",
+            {
+              suggestion: "Add [[r2_buckets]] binding to aerostack.toml"
+            }
+          );
+        }
+        try {
+          const listed = await this._storage.list({ prefix });
+          return listed.objects.map((obj) => ({
+            key: obj.key,
+            size: obj.size,
+            uploaded: obj.uploaded,
+            contentType: obj.httpMetadata?.contentType
+          }));
+        } catch (err) {
+          throw new StorageError(
+            "STORAGE_DELETE_FAILED" /* STORAGE_DELETE_FAILED */,
+            "Failed to list storage objects",
+            {
+              cause: err.message
+            },
+            { prefix }
+          );
+        }
+      }
+    };
+  }
+  /**
+   * AI operations using Cloudflare AI
+   */
+  get ai() {
+    return {
+      /**
+       * Generate chat completion
+       */
+      chat: async (messages, options) => {
+        if (!this._ai) {
+          throw new AIError(
+            "AI_NOT_CONFIGURED" /* AI_NOT_CONFIGURED */,
+            "AI binding not configured",
+            {
+              suggestion: "AI binding is automatically available in Workers"
+            }
+          );
+        }
+        try {
+          const model = options?.model || "@cf/meta/llama-3-8b-instruct";
+          const result = await this._ai.run(model, {
+            messages,
+            temperature: options?.temperature,
+            max_tokens: options?.maxTokens,
+            stream: options?.stream || false
+          });
+          return {
+            response: result.response || "",
+            usage: result.usage
+          };
+        } catch (err) {
+          throw new AIError(
+            "AI_REQUEST_FAILED" /* AI_REQUEST_FAILED */,
+            "AI chat request failed",
+            {
+              suggestion: "Check model name and message format",
+              cause: err.message
+            },
+            { messages, options }
+          );
+        }
+      },
+      /**
+       * Generate text embeddings
+       */
+      embed: async (text, options) => {
+        if (!this._ai) {
+          throw new AIError(
+            "AI_NOT_CONFIGURED" /* AI_NOT_CONFIGURED */,
+            "AI binding not configured",
+            {
+              suggestion: "AI binding is automatically available in Workers"
+            }
+          );
+        }
+        try {
+          const model = options?.model || "@cf/baai/bge-base-en-v1.5";
+          const result = await this._ai.run(model, { text });
+          return {
+            embedding: result.data[0],
+            model
+          };
+        } catch (err) {
+          throw new AIError(
+            "AI_REQUEST_FAILED" /* AI_REQUEST_FAILED */,
+            "AI embedding request failed",
+            {
+              suggestion: "Check model name and text input",
+              cause: err.message
+            },
+            { text, options }
+          );
+        }
+      },
+      /**
+       * Generate text from prompt
+       */
+      generate: async (prompt, options) => {
+        if (!this._ai) {
+          throw new AIError(
+            "AI_NOT_CONFIGURED" /* AI_NOT_CONFIGURED */,
+            "AI binding not configured",
+            {
+              suggestion: "AI binding is automatically available in Workers"
+            }
+          );
+        }
+        try {
+          const model = options?.model || "@cf/meta/llama-3-8b-instruct";
+          const result = await this._ai.run(model, {
+            prompt,
+            temperature: options?.temperature,
+            max_tokens: options?.maxTokens
+          });
+          return {
+            text: result.response || "",
+            usage: result.usage
+          };
+        } catch (err) {
+          throw new AIError(
+            "AI_REQUEST_FAILED" /* AI_REQUEST_FAILED */,
+            "AI generation request failed",
+            {
+              suggestion: "Check model name and prompt",
+              cause: err.message
+            },
+            { prompt, options }
+          );
+        }
+      }
+    };
+  }
+  /**
+   * Service invocation via Workers Dispatch
+   */
+  get services() {
+    return {
+      /**
+       * Invoke another service via RPC
+       */
+      invoke: async (serviceName, data, options) => {
+        if (!this._dispatcher) {
+          throw new ServiceError(
+            "SERVICE_INVOKE_FAILED" /* SERVICE_INVOKE_FAILED */,
+            "Service dispatcher not configured",
+            {
+              suggestion: "Configure Workers Dispatch namespace in aerostack.toml"
+            }
+          );
+        }
+        try {
+          const id = this._dispatcher.idFromName(serviceName);
+          const stub = this._dispatcher.get(id);
+          const timeout = options?.timeout || 3e4;
+          const controller = new AbortController();
+          const timeoutId = setTimeout(() => controller.abort(), timeout);
+          const response = await stub.fetch(
+            new Request("https://internal/", {
+              method: "POST",
+              body: JSON.stringify(data),
+              signal: controller.signal
+            })
+          );
+          clearTimeout(timeoutId);
+          return await response.json();
+        } catch (err) {
+          throw new ServiceError(
+            "SERVICE_INVOKE_FAILED" /* SERVICE_INVOKE_FAILED */,
+            `Failed to invoke service: ${serviceName}`,
+            {
+              suggestion: "Check service name and dispatcher binding",
+              cause: err.message
+            },
+            { serviceName, data }
+          );
+        }
+      }
+    };
+  }
+  // ========== Private Helper Methods ==========
+  async routeQuery(sql, params) {
+    const target = this.determineTarget(sql);
+    if (target === "postgres" && this.pgPool) {
+      try {
+        const result = await this.pgPool.query(sql, params);
+        return {
+          results: result.rows,
+          success: true,
+          meta: { target: "postgres", rowCount: result.rowCount || 0 }
+        };
+      } catch (err) {
+        throw DatabaseError.fromPostgresError(err, { sql, params, target: "postgres" });
+      }
+    }
+    if (this._d1) {
+      try {
+        const result = await this._d1.prepare(sql).bind(...params).all();
+        return {
+          results: result.results || [],
+          success: result.success,
+          meta: { target: "d1", duration: result.meta?.duration }
+        };
+      } catch (err) {
+        throw DatabaseError.fromD1Error(err, { sql, params, target: "d1" });
+      }
+    }
+    throw new DatabaseError(
+      "DB_CONNECTION_FAILED" /* DB_CONNECTION_FAILED */,
+      "No database connection available",
+      {
+        suggestion: "Configure DB or Postgres connection in aerostack.toml"
+      }
+    );
+  }
+  determineTarget(sql) {
+    const normalized = sql.toLowerCase();
+    if (normalized.includes("aerostack:target=postgres")) return "postgres";
+    if (normalized.includes("aerostack:target=d1")) return "d1";
+    for (const [table, target] of Object.entries(this.routingRules.tables)) {
+      if (normalized.includes(table.toLowerCase())) {
+        return target;
+      }
+    }
+    const complexTriggers = ["join", "group by", "having", "union", "intersect", "except"];
+    if (complexTriggers.some((trigger) => normalized.includes(trigger))) {
+      return "postgres";
+    }
+    return "d1";
+  }
+  async introspectD1() {
+    if (!this._d1) {
+      throw new DatabaseError("DB_CONNECTION_FAILED" /* DB_CONNECTION_FAILED */, "D1 not configured");
+    }
+    const result = await this._d1.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'").all();
+    const tables = [];
+    for (const row of result.results) {
+      const tableName = row.name;
+      const columns = await this._d1.prepare(`PRAGMA table_info(${tableName})`).all();
+      tables.push({
+        name: tableName,
+        columns: columns.results.map((col) => ({
+          name: col.name,
+          type: col.type,
+          nullable: col.notnull === 0,
+          defaultValue: col.dflt_value,
+          isPrimaryKey: col.pk === 1
+        })),
+        database: "d1"
+      });
+    }
+    return { tables, database: "d1" };
+  }
+  async introspectPostgres() {
+    if (!this.pgPool) {
+      throw new DatabaseError("DB_CONNECTION_FAILED" /* DB_CONNECTION_FAILED */, "Postgres not configured");
+    }
+    const result = await this.pgPool.query(`
+            SELECT table_name 
+            FROM information_schema.tables 
+            WHERE table_schema = 'public'
+        `);
+    const tables = [];
+    for (const row of result.rows) {
+      const tableName = row.table_name;
+      const columns = await this.pgPool.query(
+        `
+                SELECT column_name, data_type, is_nullable, column_default
+                FROM information_schema.columns
+                WHERE table_name = $1
+            `,
+        [tableName]
+      );
+      tables.push({
+        name: tableName,
+        columns: columns.rows.map((col) => ({
+          name: col.column_name,
+          type: col.data_type,
+          nullable: col.is_nullable === "YES",
+          defaultValue: col.column_default
+        })),
+        database: "postgres"
+      });
+    }
+    return { tables, database: "postgres" };
+  }
+  findPostgresConnStr(env) {
+    const entry = Object.entries(env).find(([key]) => key.endsWith("_DATABASE_URL"));
+    return entry ? entry[1] : void 0;
+  }
+};
+export {
+  AIError,
+  AerostackClient,
+  AerostackServer,
+  AuthenticationError,
+  CacheError,
+  ClientError,
+  ClientErrorCode,
+  DatabaseError,
+  ErrorCode,
+  NetworkError,
+  QueueError,
+  ServerError,
+  ServiceError,
+  StorageError,
+  ValidationError
+};