@seaverse/dataservice 1.0.0

package/dist/index.mjs

@@ -0,0 +1,342 @@
+// src/types.ts
+var DataServiceError = class extends Error {
+  constructor(message, code, details, hint, statusCode) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.hint = hint;
+    this.statusCode = statusCode;
+    this.name = "DataServiceError";
+  }
+};
+
+// src/client.ts
+function extractAppId() {
+  if (typeof globalThis !== "undefined" && "location" in globalThis) {
+    const location = globalThis.location;
+    const hostname = location.hostname;
+    const withoutSeaverse = hostname.replace(/\.app\.seaverse\.ai$/, "").replace(/\.seaverse\.ai$/, "");
+    return withoutSeaverse !== hostname ? withoutSeaverse : hostname;
+  }
+  if (typeof process !== "undefined" && process.env) {
+    return process.env.SEAVERSE_APP_ID || "default";
+  }
+  return "default";
+}
+var HTTPClient = class {
+  baseUrl;
+  headers;
+  fetchFn;
+  timeout;
+  constructor(config) {
+    this.baseUrl = config.url.replace(/\/$/, "");
+    this.fetchFn = config.options?.fetch || globalThis.fetch;
+    this.timeout = config.options?.timeout || 3e4;
+    this.headers = {
+      "Authorization": config.token,
+      "Content-Type": "application/json",
+      "Prefer": "return=representation",
+      ...config.options?.headers
+    };
+  }
+  /**
+   * Make HTTP request with timeout and error handling
+   */
+  async request(method, path, body, additionalHeaders) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await this.fetchFn(`${this.baseUrl}${path}`, {
+        method,
+        headers: { ...this.headers, ...additionalHeaders },
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        let error;
+        try {
+          error = await response.json();
+        } catch {
+          error = { message: response.statusText };
+        }
+        throw new DataServiceError(
+          error.message || "Request failed",
+          error.code,
+          error.details,
+          error.hint,
+          response.status
+        );
+      }
+      const text = await response.text();
+      return text ? JSON.parse(text) : null;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof DataServiceError) {
+        throw error;
+      }
+      if (error.name === "AbortError") {
+        throw new DataServiceError("Request timeout", "TIMEOUT");
+      }
+      throw new DataServiceError(
+        error.message || "Unknown error",
+        "NETWORK_ERROR"
+      );
+    }
+  }
+  async get(path, params) {
+    const query = params ? "?" + new URLSearchParams(params).toString() : "";
+    return this.request("GET", `${path}${query}`);
+  }
+  async post(path, body, headers) {
+    return this.request("POST", path, body, headers);
+  }
+  async patch(path, body) {
+    return this.request("PATCH", path, body);
+  }
+  async delete(path) {
+    await this.request("DELETE", path);
+  }
+};
+var QueryBuilderImpl = class {
+  constructor(client, tablePath, appId, collectionName) {
+    this.client = client;
+    this.tablePath = tablePath;
+    this.appId = appId;
+    this.collectionName = collectionName;
+  }
+  filters = [];
+  ordering = null;
+  limitValue = null;
+  offsetValue = null;
+  eq(field, value) {
+    this.filters.push(`${field}=eq.${encodeURIComponent(String(value))}`);
+    return this;
+  }
+  neq(field, value) {
+    this.filters.push(`${field}=neq.${encodeURIComponent(String(value))}`);
+    return this;
+  }
+  gt(field, value) {
+    this.filters.push(`${field}=gt.${encodeURIComponent(String(value))}`);
+    return this;
+  }
+  gte(field, value) {
+    this.filters.push(`${field}=gte.${encodeURIComponent(String(value))}`);
+    return this;
+  }
+  lt(field, value) {
+    this.filters.push(`${field}=lt.${encodeURIComponent(String(value))}`);
+    return this;
+  }
+  lte(field, value) {
+    this.filters.push(`${field}=lte.${encodeURIComponent(String(value))}`);
+    return this;
+  }
+  like(field, pattern) {
+    this.filters.push(`${field}=like.${encodeURIComponent(pattern)}`);
+    return this;
+  }
+  ilike(field, pattern) {
+    this.filters.push(`${field}=ilike.${encodeURIComponent(pattern)}`);
+    return this;
+  }
+  in(field, values) {
+    const encoded = values.map((v) => encodeURIComponent(String(v))).join(",");
+    this.filters.push(`${field}=in.(${encoded})`);
+    return this;
+  }
+  contains(value) {
+    this.filters.push(`data=@>.${encodeURIComponent(JSON.stringify(value))}`);
+    return this;
+  }
+  overlaps(value) {
+    this.filters.push(`data=&&.${encodeURIComponent(JSON.stringify(value))}`);
+    return this;
+  }
+  order(field, options = {}) {
+    let orderStr = field;
+    if (options.descending)
+      orderStr += ".desc";
+    if (options.nullsFirst !== void 0) {
+      orderStr += options.nullsFirst ? ".nullsfirst" : ".nullslast";
+    }
+    this.ordering = orderStr;
+    return this;
+  }
+  limit(count) {
+    this.limitValue = count;
+    return this;
+  }
+  offset(count) {
+    this.offsetValue = count;
+    return this;
+  }
+  async execute() {
+    const params = {
+      app_id: `eq.${this.appId}`,
+      collection_name: `eq.${this.collectionName}`,
+      ...Object.fromEntries(this.filters.map((f, i) => [`filter${i}`, f]))
+    };
+    if (this.ordering)
+      params.order = this.ordering;
+    if (this.limitValue !== null)
+      params.limit = String(this.limitValue);
+    if (this.offsetValue !== null)
+      params.offset = String(this.offsetValue);
+    return this.client.get(this.tablePath, params);
+  }
+  async count() {
+    const params = {
+      app_id: `eq.${this.appId}`,
+      collection_name: `eq.${this.collectionName}`,
+      ...Object.fromEntries(this.filters.map((f, i) => [`filter${i}`, f]))
+    };
+    const response = await this.client.get(this.tablePath, {
+      ...params,
+      select: "count"
+    });
+    return response.length;
+  }
+};
+var CollectionImpl = class {
+  constructor(client, tablePath, appId, collectionName) {
+    this.client = client;
+    this.tablePath = tablePath;
+    this.appId = appId;
+    this.collectionName = collectionName;
+  }
+  async insert(data, id) {
+    const payload = {
+      app_id: this.appId,
+      collection_name: this.collectionName,
+      data
+    };
+    if (id) {
+      payload.id = id;
+    }
+    const response = await this.client.post(this.tablePath, payload);
+    return Array.isArray(response) ? response[0] : response;
+  }
+  async get(id) {
+    return this.selectById(id);
+  }
+  select() {
+    return new QueryBuilderImpl(this.client, this.tablePath, this.appId, this.collectionName);
+  }
+  async selectById(id) {
+    try {
+      const results = await this.client.get(
+        `/user_data?id=eq.${id}&app_id=eq.${this.appId}&collection_name=eq.${this.collectionName}`
+      );
+      return results[0] || null;
+    } catch (error) {
+      if (error.statusCode === 404) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  async update(id, data) {
+    const response = await this.client.patch(
+      `/user_data?id=eq.${id}&app_id=eq.${this.appId}&collection_name=eq.${this.collectionName}`,
+      { data }
+    );
+    return Array.isArray(response) ? response[0] : response;
+  }
+  async patch(id, partial) {
+    const existing = await this.selectById(id);
+    if (!existing) {
+      throw new DataServiceError(`Record with id ${id} not found`, "NOT_FOUND");
+    }
+    const merged = { ...existing.data, ...partial };
+    return this.update(id, merged);
+  }
+  async delete(id) {
+    await this.client.delete(
+      `/user_data?id=eq.${id}&app_id=eq.${this.appId}&collection_name=eq.${this.collectionName}`
+    );
+  }
+  async softDelete(id) {
+    const response = await this.client.post("/rpc/soft_delete_user_data", {
+      p_id: id
+    });
+    return response;
+  }
+  async restore(id) {
+    const response = await this.client.post("/rpc/restore_user_data", {
+      p_id: id
+    });
+    return response;
+  }
+  async search(criteria) {
+    return this.client.get(this.tablePath, {
+      app_id: `eq.${this.appId}`,
+      collection_name: `eq.${this.collectionName}`,
+      data: `@>.${JSON.stringify(criteria)}`
+    });
+  }
+  async count() {
+    const results = await this.client.get(this.tablePath, {
+      app_id: `eq.${this.appId}`,
+      collection_name: `eq.${this.collectionName}`
+    });
+    return results.length;
+  }
+};
+var DataTableImpl = class {
+  constructor(client, tablePath, appId) {
+    this.client = client;
+    this.tablePath = tablePath;
+    this.appId = appId;
+  }
+  collection(name) {
+    return new CollectionImpl(this.client, this.tablePath, this.appId, name);
+  }
+  async batchInsert(baseCollectionName, records) {
+    const results = [];
+    for (let i = 0; i < records.length; i++) {
+      const uniqueCollectionName = `${baseCollectionName}_${Date.now()}_${i}`;
+      const collection = new CollectionImpl(
+        this.client,
+        this.tablePath,
+        this.appId,
+        uniqueCollectionName
+      );
+      const result = await collection.insert(records[i]);
+      results.push(result);
+      if (i < records.length - 1) {
+        await new Promise((resolve) => setTimeout(resolve, 1));
+      }
+    }
+    return results;
+  }
+};
+var DataServiceClientImpl = class {
+  client;
+  userData;
+  appId;
+  constructor(config) {
+    this.client = new HTTPClient(config);
+    this.appId = extractAppId();
+    this.userData = new DataTableImpl(this.client, "/user_data", this.appId);
+  }
+  async getStats() {
+    const response = await this.client.post("/rpc/get_user_data_stats");
+    return Array.isArray(response) ? response[0] : response;
+  }
+  async health() {
+    return this.client.post("/rpc/health");
+  }
+};
+function createClient(config) {
+  return new DataServiceClientImpl(config);
+}
+
+// src/index.ts
+var VERSION = "1.0.0";
+export {
+  DataServiceError,
+  VERSION,
+  createClient
+};

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@seaverse/dataservice",
+  "version": "1.0.0",
+  "description": "AI-Friendly Universal Data Storage SDK for TypeScript/JavaScript",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:examples": "tsx examples/test-examples.ts",
+    "lint": "eslint src --ext .ts",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "security:check": "echo 'Checking for sensitive files...' && ! git ls-files | grep -E '\\.env(\\.development|\\.production)?$'",
+    "prepublishOnly": "npm run security:check && npm run build"
+  },
+  "keywords": [
+    "data-storage",
+    "postgrest",
+    "database",
+    "sdk",
+    "typescript",
+    "ai-friendly",
+    "jsonb",
+    "rls"
+  ],
+  "author": "SeaVerse Team <support@seaverse.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/seaverseai/sv-sdk.git",
+    "directory": "packages/dataservice"
+  },
+  "bugs": {
+    "url": "https://github.com/seaverseai/sv-sdk/issues"
+  },
+  "homepage": "https://github.com/seaverseai/sv-sdk/tree/main/packages/dataservice#readme",
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "@typescript-eslint/eslint-plugin": "^6.19.0",
+    "@typescript-eslint/parser": "^6.19.0",
+    "@vitest/coverage-v8": "^1.2.0",
+    "eslint": "^8.56.0",
+    "prettier": "^3.2.4",
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.3",
+    "vitest": "^1.2.0"
+  },
+  "dependencies": {
+    "dotenv": "^17.2.3",
+    "tsx": "^4.21.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}