@planescrm/sdk 0.2.0

package/dist/index.js

@@ -0,0 +1,646 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AuthenticationError: () => AuthenticationError,
+  AuthorizationError: () => AuthorizationError,
+  BaseResource: () => BaseResource,
+  Blueprint: () => Blueprint,
+  BlueprintClient: () => BlueprintClient,
+  BlueprintError: () => BlueprintError,
+  CalendarEventResource: () => CalendarEventResource,
+  ContractResource: () => ContractResource,
+  CustomerResource: () => CustomerResource,
+  DEFAULT_BASE_URL: () => DEFAULT_BASE_URL,
+  DEFAULT_MAX_RETRIES: () => DEFAULT_MAX_RETRIES,
+  DEFAULT_TIMEOUT: () => DEFAULT_TIMEOUT,
+  EstimateResource: () => EstimateResource,
+  InventoryResource: () => InventoryResource,
+  InvoiceResource: () => InvoiceResource,
+  JobResource: () => JobResource,
+  NotFoundError: () => NotFoundError,
+  OAuthError: () => OAuthError,
+  OpportunityResource: () => OpportunityResource,
+  PropertyResource: () => PropertyResource,
+  RateLimitError: () => RateLimitError,
+  ServerError: () => ServerError,
+  ValidationError: () => ValidationError,
+  WebhookVerificationError: () => WebhookVerificationError,
+  buildAuthorizeUrl: () => buildAuthorizeUrl,
+  exchangeCode: () => exchangeCode,
+  parseWebhookEvent: () => parseWebhookEvent,
+  refreshAccessToken: () => refreshAccessToken,
+  verifyWebhookSignature: () => verifyWebhookSignature
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/config.ts
+var DEFAULT_BASE_URL = "https://api.planescrm.com/api/v1";
+var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_MAX_RETRIES = 3;
+
+// src/errors.ts
+var BlueprintError = class extends Error {
+  constructor(message, status, code) {
+    super(message);
+    this.name = "BlueprintError";
+    this.status = status;
+    this.code = code;
+  }
+};
+var AuthenticationError = class extends BlueprintError {
+  constructor(message = "Authentication failed") {
+    super(message, 401, "authentication_error");
+    this.name = "AuthenticationError";
+  }
+};
+var AuthorizationError = class extends BlueprintError {
+  constructor(message = "Insufficient permissions") {
+    super(message, 403, "authorization_error");
+    this.name = "AuthorizationError";
+  }
+};
+var NotFoundError = class extends BlueprintError {
+  constructor(message = "Resource not found") {
+    super(message, 404, "not_found");
+    this.name = "NotFoundError";
+  }
+};
+var ValidationError = class extends BlueprintError {
+  constructor(message = "Validation failed", fieldErrors = []) {
+    super(message, 400, "validation_error");
+    this.name = "ValidationError";
+    this.fieldErrors = fieldErrors;
+  }
+};
+var RateLimitError = class extends BlueprintError {
+  constructor(retryAfter = 1, message = "Rate limit exceeded") {
+    super(message, 429, "rate_limit_error");
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var ServerError = class extends BlueprintError {
+  constructor(message = "Internal server error") {
+    super(message, 500, "server_error");
+    this.name = "ServerError";
+  }
+};
+var WebhookVerificationError = class extends BlueprintError {
+  constructor(message = "Webhook signature verification failed") {
+    super(message, 400, "webhook_verification_error");
+    this.name = "WebhookVerificationError";
+  }
+};
+var OAuthError = class extends BlueprintError {
+  constructor(errorCode, message = "OAuth error") {
+    super(message, 400, "oauth_error");
+    this.name = "OAuthError";
+    this.errorCode = errorCode;
+  }
+};
+
+// src/http.ts
+var HttpClient = class {
+  constructor(config) {
+    this.baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.accessToken = config.accessToken;
+    this.apiKey = config.apiKey;
+    this.timeout = config.timeout ?? DEFAULT_TIMEOUT;
+    this.retryOnRateLimit = config.retryOnRateLimit !== false;
+    this.maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
+  }
+  async request(options) {
+    const url = this.buildUrl(options.path, options.params);
+    const headers = {
+      "Content-Type": "application/json",
+      ...this.getAuthHeaders(),
+      ...options.headers
+    };
+    const fetchOptions = {
+      method: options.method,
+      headers,
+      signal: AbortSignal.timeout(this.timeout)
+    };
+    if (options.body !== void 0) {
+      fetchOptions.body = JSON.stringify(options.body);
+    }
+    let lastError;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      const response = await fetch(url, fetchOptions);
+      if (response.ok) {
+        if (response.status === 204) {
+          return void 0;
+        }
+        return await response.json();
+      }
+      if (response.status === 429 && this.retryOnRateLimit && attempt < this.maxRetries) {
+        const retryAfter = this.parseRetryAfter(response);
+        await this.sleep(retryAfter * 1e3);
+        continue;
+      }
+      lastError = await this.mapError(response);
+      if (response.status !== 429 || !this.retryOnRateLimit) {
+        throw lastError;
+      }
+    }
+    throw lastError ?? new RateLimitError();
+  }
+  getAuthHeaders() {
+    if (this.accessToken) {
+      return { Authorization: `Bearer ${this.accessToken}` };
+    }
+    if (this.apiKey) {
+      return { "X-API-Key": this.apiKey };
+    }
+    return {};
+  }
+  buildUrl(path, params) {
+    const url = new URL(`${this.baseUrl}${path}`);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0 && value !== null) {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    return url.toString();
+  }
+  parseRetryAfter(response) {
+    const header = response.headers.get("Retry-After");
+    if (header) {
+      const seconds = Number(header);
+      if (!Number.isNaN(seconds) && seconds > 0) {
+        return seconds;
+      }
+    }
+    return 1;
+  }
+  async mapError(response) {
+    let body = {};
+    try {
+      body = await response.json();
+    } catch {
+    }
+    const message = body["message"] ?? response.statusText ?? "Request failed";
+    switch (response.status) {
+      case 400: {
+        const fieldErrors = body["errors"] ?? [];
+        return new ValidationError(message, fieldErrors);
+      }
+      case 401:
+        return new AuthenticationError(message);
+      case 403:
+        return new AuthorizationError(message);
+      case 404:
+        return new NotFoundError(message);
+      case 429: {
+        const retryAfter = this.parseRetryAfter(response);
+        return new RateLimitError(retryAfter, message);
+      }
+      default:
+        if (response.status >= 500) {
+          return new ServerError(message);
+        }
+        return new BlueprintError(message, response.status, "unknown_error");
+    }
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+// src/resources/base-resource.ts
+var BaseResource = class {
+  constructor(http2, basePath) {
+    this.http = http2;
+    this.basePath = basePath;
+  }
+  /**
+   * List entities with optional filters and pagination.
+   */
+  async list(params) {
+    return this.http.request({
+      method: "GET",
+      path: this.basePath,
+      params
+    });
+  }
+  /**
+   * Get a single entity by ID.
+   */
+  async get(id) {
+    return this.http.request({
+      method: "GET",
+      path: `${this.basePath}/${id}`
+    });
+  }
+  /**
+   * Create a new entity.
+   */
+  async create(data) {
+    return this.http.request({
+      method: "POST",
+      path: this.basePath,
+      body: data
+    });
+  }
+  /**
+   * Update an existing entity.
+   */
+  async update(id, data) {
+    return this.http.request({
+      method: "PATCH",
+      path: `${this.basePath}/${id}`,
+      body: data
+    });
+  }
+  /**
+   * Delete an entity by ID.
+   */
+  async delete(id) {
+    await this.http.request({
+      method: "DELETE",
+      path: `${this.basePath}/${id}`
+    });
+  }
+};
+
+// src/resources/opportunities.ts
+var OpportunityResource = class extends BaseResource {
+  constructor(http2) {
+    super(http2, "/opportunities");
+  }
+};
+
+// src/resources/customers.ts
+var CustomerResource = class extends BaseResource {
+  constructor(http2) {
+    super(http2, "/customers");
+  }
+};
+
+// src/resources/properties.ts
+var PropertyResource = class extends BaseResource {
+  constructor(http2) {
+    super(http2, "/properties");
+  }
+};
+
+// src/resources/calendar-events.ts
+var CalendarEventResource = class extends BaseResource {
+  constructor(http2) {
+    super(http2, "/calendar-events");
+  }
+};
+
+// src/resources/contracts.ts
+var ContractResource = class extends BaseResource {
+  constructor(http2) {
+    super(http2, "/contracts");
+  }
+};
+
+// src/resources/jobs.ts
+var JobResource = class extends BaseResource {
+  constructor(http2) {
+    super(http2, "/jobs");
+  }
+};
+
+// src/resources/estimates.ts
+var EstimateResource = class extends BaseResource {
+  constructor(http2) {
+    super(http2, "/estimates");
+  }
+};
+
+// src/resources/invoices.ts
+var InvoiceResource = class extends BaseResource {
+  constructor(http2) {
+    super(http2, "/invoices");
+  }
+};
+
+// src/resources/inventory.ts
+var InventoryResource = class extends BaseResource {
+  constructor(http2) {
+    super(http2, "/inventory/items");
+  }
+};
+
+// src/client.ts
+var BlueprintClient = class {
+  constructor(config) {
+    if (!config.accessToken && !config.apiKey) {
+      throw new Error("BlueprintClient requires either accessToken or apiKey");
+    }
+    if (config.accessToken && config.apiKey) {
+      throw new Error("BlueprintClient requires either accessToken or apiKey, not both");
+    }
+    this.http = new HttpClient(config);
+  }
+  get opportunities() {
+    if (!this._opportunities) {
+      this._opportunities = new OpportunityResource(this.http);
+    }
+    return this._opportunities;
+  }
+  get customers() {
+    if (!this._customers) {
+      this._customers = new CustomerResource(this.http);
+    }
+    return this._customers;
+  }
+  get properties() {
+    if (!this._properties) {
+      this._properties = new PropertyResource(this.http);
+    }
+    return this._properties;
+  }
+  get calendarEvents() {
+    if (!this._calendarEvents) {
+      this._calendarEvents = new CalendarEventResource(this.http);
+    }
+    return this._calendarEvents;
+  }
+  get contracts() {
+    if (!this._contracts) {
+      this._contracts = new ContractResource(this.http);
+    }
+    return this._contracts;
+  }
+  get jobs() {
+    if (!this._jobs) {
+      this._jobs = new JobResource(this.http);
+    }
+    return this._jobs;
+  }
+  get estimates() {
+    if (!this._estimates) {
+      this._estimates = new EstimateResource(this.http);
+    }
+    return this._estimates;
+  }
+  get invoices() {
+    if (!this._invoices) {
+      this._invoices = new InvoiceResource(this.http);
+    }
+    return this._invoices;
+  }
+  get inventory() {
+    if (!this._inventory) {
+      this._inventory = new InventoryResource(this.http);
+    }
+    return this._inventory;
+  }
+};
+
+// src/agent.ts
+var http = __toESM(require("http"));
+var Blueprint = {
+  /**
+   * Register action handlers and start an HTTP server to receive action requests.
+   *
+   * @example
+   * ```ts
+   * Blueprint.register([
+   *   {
+   *     type: 'send_email',
+   *     async execute(ctx) {
+   *       // ... send email logic
+   *       return { status: 'completed', output: { sent: true } };
+   *     },
+   *   },
+   * ], { port: 3000 });
+   * ```
+   */
+  register(handlers, options) {
+    const port = options?.port ?? 3e3;
+    const basePath = options?.path ?? "/actions";
+    const onError = options?.onError;
+    const handlerMap = /* @__PURE__ */ new Map();
+    for (const handler of handlers) {
+      handlerMap.set(handler.type, handler);
+    }
+    const server = http.createServer(async (req, res) => {
+      if (req.method !== "POST" || req.url !== basePath) {
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Not found" }));
+        return;
+      }
+      try {
+        const body = await readBody(req);
+        let context;
+        try {
+          context = JSON.parse(body);
+        } catch {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Malformed request body" }));
+          return;
+        }
+        if (!context.action?.type) {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Missing action.type in request body" }));
+          return;
+        }
+        const handler = handlerMap.get(context.action.type);
+        if (!handler) {
+          res.writeHead(404, { "Content-Type": "application/json" });
+          res.end(
+            JSON.stringify({
+              error: `No handler registered for action type: ${context.action.type}`
+            })
+          );
+          return;
+        }
+        let result;
+        try {
+          result = await handler.execute(context);
+        } catch (err) {
+          const errorMessage = err instanceof Error ? err.message : "Unknown handler error";
+          if (onError && err instanceof Error) {
+            onError(err);
+          }
+          result = {
+            status: "failed",
+            error: errorMessage,
+            retryable: false
+          };
+        }
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(result));
+      } catch (err) {
+        if (onError && err instanceof Error) {
+          onError(err);
+        }
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Internal server error" }));
+      }
+    });
+    server.listen(port);
+    const shutdown = () => {
+      server.close();
+    };
+    process.on("SIGTERM", shutdown);
+    process.on("SIGINT", shutdown);
+    return server;
+  }
+};
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => resolve(Buffer.concat(chunks).toString()));
+    req.on("error", reject);
+  });
+}
+
+// src/webhooks.ts
+var import_node_crypto = require("crypto");
+function verifyWebhookSignature(payload, signature, secret) {
+  if (!signature || !secret || !payload) {
+    return false;
+  }
+  const prefix = "sha256=";
+  if (!signature.startsWith(prefix)) {
+    return false;
+  }
+  const receivedHex = signature.slice(prefix.length);
+  if (!receivedHex) {
+    return false;
+  }
+  const expectedHmac = (0, import_node_crypto.createHmac)("sha256", secret).update(payload).digest("hex");
+  const receivedBuf = Buffer.from(receivedHex, "hex");
+  const expectedBuf = Buffer.from(expectedHmac, "hex");
+  if (receivedBuf.length !== expectedBuf.length) {
+    return false;
+  }
+  return (0, import_node_crypto.timingSafeEqual)(receivedBuf, expectedBuf);
+}
+function parseWebhookEvent(body, signature, secret) {
+  if (!verifyWebhookSignature(body, signature, secret)) {
+    throw new WebhookVerificationError();
+  }
+  return JSON.parse(body);
+}
+
+// src/oauth.ts
+var import_node_crypto2 = require("crypto");
+function buildAuthorizeUrl(options) {
+  const state = options.state ?? (0, import_node_crypto2.randomBytes)(16).toString("hex");
+  const baseUrl = options.baseUrl.replace(/\/+$/, "");
+  const url = new URL(`${baseUrl}/oauth/authorize`);
+  url.searchParams.set("client_id", options.clientId);
+  url.searchParams.set("redirect_uri", options.redirectUri);
+  url.searchParams.set("scope", options.scopes.join(" "));
+  url.searchParams.set("response_type", "code");
+  url.searchParams.set("state", state);
+  return url.toString();
+}
+async function exchangeCode(options) {
+  const baseUrl = options.baseUrl.replace(/\/+$/, "");
+  const url = `${baseUrl}/oauth/token`;
+  const body = new URLSearchParams({
+    grant_type: "authorization_code",
+    client_id: options.clientId,
+    client_secret: options.clientSecret,
+    code: options.code,
+    redirect_uri: options.redirectUri
+  });
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: body.toString()
+  });
+  if (!response.ok) {
+    const errorBody = await response.json().catch(() => ({}));
+    const errorCode = errorBody["error"] ?? "unknown_error";
+    const errorDescription = errorBody["error_description"] ?? "Token exchange failed";
+    throw new OAuthError(errorCode, errorDescription);
+  }
+  return await response.json();
+}
+async function refreshAccessToken(options) {
+  const baseUrl = options.baseUrl.replace(/\/+$/, "");
+  const url = `${baseUrl}/oauth/token`;
+  const body = new URLSearchParams({
+    grant_type: "refresh_token",
+    client_id: options.clientId,
+    client_secret: options.clientSecret,
+    refresh_token: options.refreshToken
+  });
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: body.toString()
+  });
+  if (!response.ok) {
+    const errorBody = await response.json().catch(() => ({}));
+    const errorCode = errorBody["error"] ?? "unknown_error";
+    const errorDescription = errorBody["error_description"] ?? "Token refresh failed";
+    throw new OAuthError(errorCode, errorDescription);
+  }
+  return await response.json();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthenticationError,
+  AuthorizationError,
+  BaseResource,
+  Blueprint,
+  BlueprintClient,
+  BlueprintError,
+  CalendarEventResource,
+  ContractResource,
+  CustomerResource,
+  DEFAULT_BASE_URL,
+  DEFAULT_MAX_RETRIES,
+  DEFAULT_TIMEOUT,
+  EstimateResource,
+  InventoryResource,
+  InvoiceResource,
+  JobResource,
+  NotFoundError,
+  OAuthError,
+  OpportunityResource,
+  PropertyResource,
+  RateLimitError,
+  ServerError,
+  ValidationError,
+  WebhookVerificationError,
+  buildAuthorizeUrl,
+  exchangeCode,
+  parseWebhookEvent,
+  refreshAccessToken,
+  verifyWebhookSignature
+});
+//# sourceMappingURL=index.js.map