flexorch-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,576 @@
+import {
+  Dataset
+} from "./chunk-7JBTDKMH.js";
+
+// src/errors.ts
+var FlexOrchError = class extends Error {
+  statusCode;
+  errorCode;
+  constructor(message, statusCode, errorCode) {
+    super(message);
+    this.name = "FlexOrchError";
+    this.statusCode = statusCode;
+    this.errorCode = errorCode;
+  }
+};
+var AuthError = class extends FlexOrchError {
+  constructor(message, statusCode = 401, errorCode) {
+    super(message, statusCode, errorCode);
+    this.name = "AuthError";
+  }
+};
+var QuotaError = class extends FlexOrchError {
+  remainingCredits;
+  resetAt;
+  constructor(message, statusCode = 402, errorCode, remainingCredits, resetAt) {
+    super(message, statusCode, errorCode);
+    this.name = "QuotaError";
+    this.remainingCredits = remainingCredits;
+    this.resetAt = resetAt;
+  }
+};
+var RateLimitError = class extends FlexOrchError {
+  retryAfter;
+  constructor(message, retryAfter = 60) {
+    super(message, 429, "RATE_LIMIT_EXCEEDED");
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var NotFoundError = class extends FlexOrchError {
+  constructor(message, errorCode) {
+    super(message, 404, errorCode);
+    this.name = "NotFoundError";
+  }
+};
+var ValidationError = class extends FlexOrchError {
+  constructor(message, errorCode) {
+    super(message, 422, errorCode);
+    this.name = "ValidationError";
+  }
+};
+var ServerError = class extends FlexOrchError {
+  constructor(message, statusCode = 500, errorCode) {
+    super(message, statusCode, errorCode);
+    this.name = "ServerError";
+  }
+};
+var JobFailedError = class extends FlexOrchError {
+  jobId;
+  failureReason;
+  constructor(jobId, failureReason) {
+    super(`Job ${jobId} failed: ${failureReason}`);
+    this.name = "JobFailedError";
+    this.jobId = jobId;
+    this.failureReason = failureReason;
+  }
+};
+var JobTimeoutError = class extends FlexOrchError {
+  jobId;
+  timeout;
+  constructor(jobId, timeout) {
+    super(`Job ${jobId} did not complete within ${timeout}s`);
+    this.name = "JobTimeoutError";
+    this.jobId = jobId;
+    this.timeout = timeout;
+  }
+};
+
+// src/transport.ts
+var RETRY_STATUSES = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+async function parseError(res) {
+  const status = res.status;
+  let message = `HTTP ${status}`;
+  let code = "";
+  try {
+    const body = await res.json();
+    const err = body["error"] ?? {};
+    code = String(err["code"] ?? "");
+    message = String(err["message"] ?? body["detail"] ?? message);
+  } catch {
+    message = await res.text().catch(() => message) || message;
+  }
+  if (status === 401) return new AuthError(message, status, code);
+  if (status === 402) return new QuotaError(message, status, code);
+  if (status === 404) return new NotFoundError(message, code);
+  if (status === 422) return new ValidationError(message, code);
+  if (status === 429) {
+    const retryAfter = parseInt(res.headers.get("Retry-After") ?? "60") || 60;
+    return new RateLimitError(message, retryAfter);
+  }
+  if (status >= 500) return new ServerError(message, status, code);
+  return new FlexOrchError(message, status, code);
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+var Transport = class {
+  baseUrl;
+  defaultHeaders;
+  timeout;
+  maxRetries;
+  fetchFn;
+  constructor(apiKey, baseUrl, timeout, maxRetries, fetchFn) {
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.timeout = timeout;
+    this.maxRetries = maxRetries;
+    this.fetchFn = fetchFn ?? globalThis.fetch.bind(globalThis);
+    this.defaultHeaders = {
+      "X-API-KEY": apiKey,
+      "User-Agent": "flexorch-sdk-js/0.1.0"
+    };
+  }
+  url(path, params) {
+    const base = `${this.baseUrl}/${path.replace(/^\//, "")}`;
+    if (!params) return base;
+    return `${base}?${new URLSearchParams(params)}`;
+  }
+  async doRequest(method, path, options = {}) {
+    const url = this.url(path, options.params);
+    const headers = { ...this.defaultHeaders };
+    let body;
+    if (options.json !== void 0) {
+      headers["Content-Type"] = "application/json";
+      body = JSON.stringify(options.json);
+    } else if (options.form) {
+      body = options.form;
+    }
+    let lastError;
+    for (let attempt = 0; attempt < this.maxRetries; attempt++) {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), this.timeout * 1e3);
+      try {
+        const res = await this.fetchFn(url, {
+          method,
+          headers,
+          body,
+          signal: controller.signal
+        });
+        clearTimeout(timer);
+        if (RETRY_STATUSES.has(res.status) && attempt < this.maxRetries - 1) {
+          const wait = parseInt(res.headers.get("Retry-After") ?? "") || 2 ** attempt;
+          await sleep(wait * 1e3);
+          continue;
+        }
+        if (!res.ok) throw await parseError(res);
+        if (res.status === 204) return null;
+        const ct = res.headers.get("content-type") ?? "";
+        if (!ct.includes("application/json")) return null;
+        const text = await res.text();
+        if (!text.trim()) return null;
+        return JSON.parse(text);
+      } catch (err) {
+        clearTimeout(timer);
+        if (err instanceof FlexOrchError) throw err;
+        lastError = err;
+        if (attempt < this.maxRetries - 1) await sleep(2 ** attempt * 1e3);
+      }
+    }
+    throw new FlexOrchError(
+      `Request failed after ${this.maxRetries} attempts: ${lastError?.message}`
+    );
+  }
+  async getBytes(path, params) {
+    const url = this.url(path, params);
+    const res = await this.fetchFn(url, { headers: this.defaultHeaders });
+    if (!res.ok) throw await parseError(res);
+    return new Uint8Array(await res.arrayBuffer());
+  }
+  get(path, params) {
+    return params ? this.doRequest("GET", path, { params }) : this.doRequest("GET", path);
+  }
+  post(path, json) {
+    return this.doRequest("POST", path, { json });
+  }
+  postForm(path, form) {
+    return this.doRequest("POST", path, { form });
+  }
+  delete(path) {
+    return this.doRequest("DELETE", path);
+  }
+};
+
+// src/models/job.ts
+var Job = class _Job {
+  id;
+  status;
+  qualityGrade;
+  qualityScore;
+  documentId;
+  hasDataset;
+  failureReason;
+  _transport;
+  constructor(data) {
+    this.id = data.id;
+    this.status = data.status;
+    this.qualityGrade = data.qualityGrade;
+    this.qualityScore = data.qualityScore;
+    this.documentId = data.documentId;
+    this.hasDataset = data.hasDataset;
+    this.failureReason = data.failureReason;
+    this._transport = data._transport;
+  }
+  static fromDict(data, transport) {
+    const quality = data["quality"] ?? {};
+    return new _Job({
+      id: String(data["job_id"] ?? data["id"] ?? ""),
+      status: String(data["status"] ?? ""),
+      qualityGrade: quality["grade"] ?? null,
+      qualityScore: quality["score"] ?? null,
+      documentId: data["document_id"] ?? null,
+      hasDataset: Boolean(data["has_dataset"] ?? false),
+      failureReason: data["failure_reason"] ?? null,
+      _transport: transport
+    });
+  }
+  async wait(opts = {}) {
+    const timeout = opts.timeout ?? 300;
+    const pollInterval = opts.pollInterval ?? 2;
+    const deadline = Date.now() + timeout * 1e3;
+    if (this.status === "completed" || this.status === "failed") {
+      if (this.status === "failed") {
+        throw new JobFailedError(this.id, this.failureReason ?? "unknown");
+      }
+      return this;
+    }
+    while (Date.now() < deadline) {
+      await sleep2(pollInterval * 1e3);
+      const data = await this._transport.get(`/jobs/${this.id}`);
+      const updated = _Job.fromDict(data, this._transport);
+      if (updated.status === "completed") return updated;
+      if (updated.status === "failed") {
+        throw new JobFailedError(updated.id, updated.failureReason ?? "unknown");
+      }
+    }
+    throw new JobTimeoutError(this.id, timeout);
+  }
+  async dataset() {
+    if (!this.hasDataset) return null;
+    const data = await this._transport.get("/datasets", {
+      job_id: this.id
+    });
+    const items = data["items"] ?? [];
+    if (items.length === 0) return null;
+    const { Dataset: Dataset2 } = await import("./dataset-IS63EK2G.js");
+    return Dataset2.fromDict(items[0], this._transport);
+  }
+  toString() {
+    return `Job(id=${this.id}, status=${this.status}, grade=${this.qualityGrade})`;
+  }
+};
+function sleep2(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// src/models/search.ts
+var SearchResult = class _SearchResult {
+  chunkId;
+  text;
+  score;
+  datasetId;
+  chunkIndex;
+  tokenCount;
+  metadata;
+  constructor(data) {
+    this.chunkId = data.chunkId;
+    this.text = data.text;
+    this.score = data.score;
+    this.datasetId = data.datasetId;
+    this.chunkIndex = data.chunkIndex;
+    this.tokenCount = data.tokenCount;
+    this.metadata = data.metadata;
+  }
+  static fromDict(data) {
+    return new _SearchResult({
+      chunkId: String(data["chunk_id"] ?? ""),
+      text: String(data["text"] ?? ""),
+      score: Number(data["score"] ?? 0),
+      datasetId: String(data["dataset_id"] ?? ""),
+      chunkIndex: Number(data["chunk_index"] ?? 0),
+      tokenCount: Number(data["token_count"] ?? 0),
+      metadata: data["metadata"] ?? {}
+    });
+  }
+  toString() {
+    return `SearchResult(score=${this.score.toFixed(3)}, datasetId=${this.datasetId}, chunkIndex=${this.chunkIndex})`;
+  }
+};
+
+// src/resources/jobs.ts
+var JobsResource = class {
+  constructor(_t) {
+    this._t = _t;
+  }
+  _t;
+  async get(jobId) {
+    const data = await this._t.get(`/jobs/${jobId}`);
+    return Job.fromDict(data, this._t);
+  }
+  async list(opts = {}) {
+    const params = {};
+    if (opts.page !== void 0) params["page"] = String(opts.page);
+    if (opts.pageSize !== void 0) params["page_size"] = String(opts.pageSize);
+    const data = await this._t.get("/jobs", params);
+    const items = data["items"] ?? [];
+    return items.map((item) => Job.fromDict(item, this._t));
+  }
+};
+
+// src/resources/datasets.ts
+var DatasetsResource = class {
+  constructor(_t) {
+    this._t = _t;
+  }
+  _t;
+  async get(datasetId) {
+    const data = await this._t.get(`/datasets/${datasetId}`);
+    return Dataset.fromDict(data, this._t);
+  }
+  async list(opts = {}) {
+    const params = {};
+    if (opts.page !== void 0) params["page"] = String(opts.page);
+    if (opts.pageSize !== void 0) params["page_size"] = String(opts.pageSize);
+    const data = await this._t.get("/datasets", params);
+    const items = data["items"] ?? [];
+    return items.map((item) => Dataset.fromDict(item, this._t));
+  }
+};
+
+// src/resources/usage.ts
+var UsageResource = class {
+  constructor(_t) {
+    this._t = _t;
+  }
+  _t;
+  async current() {
+    const data = await this._t.get("/usage/current");
+    return {
+      plan: String(data["plan"] ?? ""),
+      creditsUsed: Number(data["credits_used"] ?? 0),
+      creditsLimit: Number(data["credits_limit"] ?? 0),
+      creditsRemaining: Number(data["credits_remaining"] ?? 0),
+      resetAt: String(data["reset_at"] ?? ""),
+      periodStart: String(data["period_start"] ?? ""),
+      periodEnd: String(data["period_end"] ?? "")
+    };
+  }
+};
+
+// src/resources/webhooks.ts
+var VALID_EVENTS = /* @__PURE__ */ new Set(["dataset.ready", "job.completed", "job.failed"]);
+function webhookFromDict(data) {
+  return {
+    id: String(data["id"] ?? ""),
+    url: String(data["url"] ?? ""),
+    events: data["events"] ?? [],
+    active: Boolean(data["active"] ?? true),
+    createdAt: String(data["created_at"] ?? "")
+  };
+}
+var WebhooksResource = class {
+  constructor(_t) {
+    this._t = _t;
+  }
+  _t;
+  async register(url, events) {
+    const invalid = events.filter((e) => !VALID_EVENTS.has(e));
+    if (invalid.length > 0) {
+      throw new Error(`Unknown event types: ${invalid.join(", ")}. Valid: ${[...VALID_EVENTS].join(", ")}`);
+    }
+    const data = await this._t.post("/webhooks", { url, events });
+    return webhookFromDict(data);
+  }
+  async list() {
+    const data = await this._t.get("/webhooks");
+    const items = data["items"] ?? [];
+    return items.map(webhookFromDict);
+  }
+  async delete(webhookId) {
+    await this._t.delete(`/webhooks/${webhookId}`);
+  }
+};
+
+// src/models/connector.ts
+var Connector = class _Connector {
+  id;
+  name;
+  type;
+  active;
+  lastTestedAt;
+  lastUsedAt;
+  createdAt;
+  constructor(data) {
+    this.id = data.id;
+    this.name = data.name;
+    this.type = data.type;
+    this.active = data.active;
+    this.lastTestedAt = data.lastTestedAt;
+    this.lastUsedAt = data.lastUsedAt;
+    this.createdAt = data.createdAt;
+  }
+  static fromDict(data) {
+    return new _Connector({
+      id: String(data["id"] ?? ""),
+      name: String(data["name"] ?? ""),
+      type: String(data["type"] ?? ""),
+      active: Boolean(data["active"] ?? true),
+      lastTestedAt: data["last_tested_at"] ?? null,
+      lastUsedAt: data["last_used_at"] ?? null,
+      createdAt: String(data["created_at"] ?? "")
+    });
+  }
+  toString() {
+    return `Connector(id=${this.id}, name=${this.name}, type=${this.type})`;
+  }
+};
+
+// src/resources/connectors.ts
+var VALID_TYPES = /* @__PURE__ */ new Set(["s3", "gcs", "azure_blob"]);
+var ConnectorsResource = class {
+  constructor(_t) {
+    this._t = _t;
+  }
+  _t;
+  async create(name, type, config) {
+    if (!VALID_TYPES.has(type)) {
+      throw new Error(`Unknown connector type "${type}". Valid: ${[...VALID_TYPES].join(", ")}`);
+    }
+    const data = await this._t.post("/connectors", { name, type, config });
+    return Connector.fromDict(data);
+  }
+  async list() {
+    const data = await this._t.get("/connectors");
+    const items = data["items"] ?? [];
+    return items.map(Connector.fromDict);
+  }
+  async get(connectorId) {
+    const data = await this._t.get(`/connectors/${connectorId}`);
+    return Connector.fromDict(data);
+  }
+  async delete(connectorId) {
+    await this._t.delete(`/connectors/${connectorId}`);
+  }
+  async test(connectorId) {
+    const data = await this._t.post(`/connectors/${connectorId}/test`) ?? {};
+    return {
+      success: Boolean(data["success"] ?? false),
+      latencyMs: data["latency_ms"] !== void 0 ? Number(data["latency_ms"]) : null,
+      message: String(data["message"] ?? "")
+    };
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.flexorch.com/v1";
+var FlexOrchClient = class {
+  jobs;
+  datasets;
+  usage;
+  webhooks;
+  connectors;
+  _transport;
+  constructor(apiKeyOrOptions = {}) {
+    const opts = typeof apiKeyOrOptions === "string" ? { apiKey: apiKeyOrOptions } : apiKeyOrOptions;
+    const apiKey = opts.apiKey ?? process.env["FLEXORCH_API_KEY"] ?? "";
+    if (!apiKey) {
+      throw new Error(
+        "No API key provided. Pass apiKey or set the FLEXORCH_API_KEY environment variable."
+      );
+    }
+    this._transport = new Transport(
+      apiKey,
+      opts.baseUrl ?? DEFAULT_BASE_URL,
+      opts.timeout ?? 30,
+      opts.maxRetries ?? 3,
+      opts._fetch
+    );
+    this.jobs = new JobsResource(this._transport);
+    this.datasets = new DatasetsResource(this._transport);
+    this.usage = new UsageResource(this._transport);
+    this.webhooks = new WebhooksResource(this._transport);
+    this.connectors = new ConnectorsResource(this._transport);
+  }
+  async process(filePath, opts = {}) {
+    const { createReadStream, statSync } = await import("fs");
+    const { basename } = await import("path");
+    if (!statSync(filePath, { throwIfNoEntry: false })) {
+      throw new Error(`File not found: ${filePath}`);
+    }
+    const form = new FormData();
+    const stream = createReadStream(filePath);
+    const chunks = [];
+    for await (const chunk of stream) {
+      chunks.push(chunk);
+    }
+    const blob = new Blob([Buffer.concat(chunks)], { type: "application/octet-stream" });
+    form.append("file", blob, basename(filePath));
+    form.append("locale", opts.locale ?? "und");
+    if (opts.pipelineConfig) {
+      form.append("pipeline_config", JSON.stringify(opts.pipelineConfig));
+    }
+    const data = await this._transport.postForm("/data-process/async", form);
+    return Job.fromDict(data, this._transport);
+  }
+  async processMany(filePaths, opts = {}) {
+    const jobs = [];
+    for (const fp of filePaths) {
+      jobs.push(await this.process(fp, opts));
+    }
+    return jobs;
+  }
+  async processFromS3(connectorId, keys, opts = {}) {
+    const jobs = [];
+    for (const key of keys) {
+      const form = new FormData();
+      form.append("locale", opts.locale ?? "und");
+      form.append("source", JSON.stringify({ connector_id: connectorId, keys: [key] }));
+      if (opts.pipelineConfig) {
+        form.append("pipeline_config", JSON.stringify(opts.pipelineConfig));
+      }
+      const data = await this._transport.postForm("/data-process/async", form);
+      jobs.push(Job.fromDict(data, this._transport));
+    }
+    return jobs;
+  }
+  async search(query, opts = {}) {
+    const body = {
+      query,
+      top_k: opts.topK ?? 10
+    };
+    if (opts.filters) {
+      const f = opts.filters;
+      const mapped = {};
+      if (f.documentType !== void 0) mapped["document_type"] = f.documentType;
+      if (f.language !== void 0) mapped["language"] = f.language;
+      if (f.piiMasked !== void 0) mapped["pii_masked"] = f.piiMasked;
+      if (f.qualityGrade !== void 0) mapped["quality_grade"] = f.qualityGrade;
+      body["filters"] = mapped;
+    }
+    const data = await this._transport.post("/search", body) ?? {};
+    const results = data["results"] ?? [];
+    return results.map(SearchResult.fromDict);
+  }
+  toString() {
+    return `FlexOrchClient(baseUrl=${DEFAULT_BASE_URL})`;
+  }
+};
+
+// src/index.ts
+var version = "0.1.0";
+export {
+  AuthError,
+  Connector,
+  Dataset,
+  FlexOrchClient,
+  FlexOrchError,
+  Job,
+  JobFailedError,
+  JobTimeoutError,
+  NotFoundError,
+  QuotaError,
+  RateLimitError,
+  SearchResult,
+  ServerError,
+  ValidationError,
+  version
+};

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "flexorch-sdk",
+  "version": "0.1.0",
+  "description": "TypeScript/JavaScript SDK for the FlexOrch API — process documents, build LLM-ready datasets",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts --clean",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "keywords": [
+    "llm",
+    "dataset",
+    "document",
+    "pipeline",
+    "flexorch",
+    "pii",
+    "rag"
+  ],
+  "author": "Flexorch Technology",
+  "license": "MIT",
+  "homepage": "https://flexorch.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/flexorch/flexorch-sdk-js"
+  },
+  "bugs": {
+    "url": "https://github.com/flexorch/flexorch-sdk-js/issues"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "tsup": "^8.3.0",
+    "typescript": "^5.4.0",
+    "@types/node": "^20.0.0",
+    "vitest": "^2.0.0"
+  }
+}