@timbrix/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,574 @@
+"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, {
+  ApiKeyAuth: () => ApiKeyAuth,
+  ApiKeysResource: () => ApiKeysResource,
+  AuthResource: () => AuthResource,
+  BearerAuth: () => BearerAuth,
+  CustomersResource: () => CustomersResource,
+  OAuthResource: () => OAuthResource,
+  OrganizationsResource: () => OrganizationsResource,
+  ProductsResource: () => ProductsResource,
+  Timbrix: () => Timbrix,
+  UsersResource: () => UsersResource,
+  WebhooksResource: () => WebhooksResource
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var import_ky = __toESM(require("ky"));
+
+// src/auth/base.ts
+var BearerAuth = class {
+  constructor(token) {
+    this.token = token;
+  }
+  getHeaders() {
+    return {
+      Authorization: `Bearer ${this.token}`
+    };
+  }
+  applyAuth(options) {
+    return {
+      ...options,
+      headers: {
+        ...options.headers,
+        ...this.getHeaders()
+      }
+    };
+  }
+};
+var ApiKeyAuth = class {
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+  }
+  getHeaders() {
+    return {
+      "X-API-Key": this.apiKey
+    };
+  }
+  applyAuth(options) {
+    return {
+      ...options,
+      headers: {
+        ...options.headers,
+        ...this.getHeaders()
+      }
+    };
+  }
+};
+
+// src/resources/api-keys.ts
+var ApiKeysResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List all API keys for an organization
+   */
+  async list(organizationId) {
+    return this.http.get(`organizations/${organizationId}/api-keys`).json();
+  }
+  /**
+   * Get API key by ID
+   */
+  async get(organizationId, apiKeyId) {
+    return this.http.get(`organizations/${organizationId}/api-keys/${apiKeyId}`).json();
+  }
+  /**
+   * Create a new API key. The plain key is returned only once in the response.
+   */
+  async create(organizationId, data) {
+    return this.http.post(`organizations/${organizationId}/api-keys`, { json: data }).json();
+  }
+  /**
+   * Update API key
+   */
+  async update(organizationId, apiKeyId, data) {
+    return this.http.put(`organizations/${organizationId}/api-keys/${apiKeyId}`, {
+      json: data
+    }).json();
+  }
+  /**
+   * Delete (revoke) API key
+   */
+  async delete(organizationId, apiKeyId) {
+    await this.http.delete(
+      `organizations/${organizationId}/api-keys/${apiKeyId}`
+    );
+  }
+  /**
+   * Get API key usage statistics for an organization
+   */
+  async stats(organizationId) {
+    return this.http.get(`organizations/${organizationId}/api-keys/stats`).json();
+  }
+  /**
+   * Validate the currently authenticated API key (uses X-API-Key header)
+   */
+  async validate() {
+    return this.http.post("api-keys/validate").json();
+  }
+};
+
+// src/resources/auth.ts
+var AuthResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Login with email and password. Returns an access token.
+   */
+  async login(data) {
+    return this.http.post("auth/login", { json: data }).json();
+  }
+  /**
+   * Logout and revoke the current access token.
+   */
+  async logout() {
+    await this.http.post("auth/logout");
+  }
+};
+
+// src/resources/customers.ts
+var CustomersResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List all customers for an organization
+   */
+  async list(organizationId) {
+    return this.http.get(`organizations/${organizationId}/customers`).json();
+  }
+  /**
+   * Get a customer by ID
+   */
+  async get(organizationId, customerId) {
+    return this.http.get(`organizations/${organizationId}/customers/${customerId}`).json();
+  }
+  /**
+   * Create a new customer
+   */
+  async create(organizationId, data) {
+    return this.http.post(`organizations/${organizationId}/customers`, { json: data }).json();
+  }
+  /**
+   * Update a customer
+   */
+  async update(organizationId, customerId, data) {
+    return this.http.put(`organizations/${organizationId}/customers/${customerId}`, {
+      json: data
+    }).json();
+  }
+  /**
+   * Delete a customer
+   */
+  async delete(organizationId, customerId) {
+    await this.http.delete(
+      `organizations/${organizationId}/customers/${customerId}`
+    );
+  }
+};
+
+// src/resources/oauth.ts
+var OAuthResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  // ─── App Management ─────────────────────────────────────────────────────────
+  /**
+   * Create a new OAuth application. Client secret is returned only once.
+   */
+  async createApp(data) {
+    return this.http.post("oauth/apps", { json: data }).json();
+  }
+  /**
+   * Get OAuth application by client ID
+   */
+  async getApp(clientId) {
+    return this.http.get(`oauth/apps/${clientId}`).json();
+  }
+  /**
+   * List OAuth applications for an organization
+   */
+  async listApps(organizationId) {
+    return this.http.get(`oauth/apps/organization/${organizationId}`).json();
+  }
+  /**
+   * Update OAuth application
+   */
+  async updateApp(clientId, data) {
+    return this.http.put(`oauth/apps/${clientId}`, { json: data }).json();
+  }
+  /**
+   * Delete OAuth application. All associated tokens will be revoked.
+   */
+  async deleteApp(clientId) {
+    await this.http.delete(`oauth/apps/${clientId}`);
+  }
+  /**
+   * List active tokens for an OAuth application
+   */
+  async listTokens(clientId) {
+    return this.http.get(`oauth/apps/${clientId}/tokens`).json();
+  }
+  /**
+   * Revoke an OAuth token (requires write:oauth-apps scope)
+   */
+  async revokeToken(tokenId) {
+    await this.http.delete(`oauth/token/${tokenId}`);
+  }
+  // ─── Token Operations ────────────────────────────────────────────────────────
+  /**
+   * Generate an access token using client credentials flow
+   */
+  async generateToken(data) {
+    return this.http.post("oauth/token", {
+      json: {
+        grant_type: "client_credentials",
+        client_id: data.clientId,
+        client_secret: data.clientSecret,
+        scope: data.scopes.join(" "),
+        user_id: data.userId
+      }
+    }).json();
+  }
+  /**
+   * Exchange an authorization code for access and refresh tokens
+   */
+  async exchangeCode(data) {
+    return this.http.post("oauth/token/exchange", {
+      json: {
+        code: data.code,
+        clientId: data.clientId,
+        clientSecret: data.clientSecret,
+        redirectUri: data.redirectUri,
+        grantType: "authorization_code",
+        codeVerifier: data.codeVerifier
+      }
+    }).json();
+  }
+  /**
+   * Refresh an access token using a refresh token
+   */
+  async refreshToken(data) {
+    return this.http.post("oauth/token/refresh", {
+      json: { refreshToken: data.refreshToken }
+    }).json();
+  }
+};
+
+// src/resources/organizations.ts
+var OrganizationsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create a new organization
+   */
+  async create(data) {
+    return this.http.post("organizations", { json: data }).json();
+  }
+  /**
+   * Get organization by ID
+   */
+  async get(id) {
+    return this.http.get(`organizations/${id}`).json();
+  }
+  /**
+   * Update organization (owner only)
+   */
+  async update(id, data) {
+    return this.http.put(`organizations/${id}`, { json: data }).json();
+  }
+  /**
+   * Update organization legal/fiscal data (owner only)
+   */
+  async updateLegalData(id, data) {
+    return this.http.put(`organizations/${id}/legal`, { json: data }).json();
+  }
+  /**
+   * Delete organization (owner only)
+   */
+  async delete(id) {
+    await this.http.delete(`organizations/${id}`);
+  }
+  /**
+   * Get organization members
+   */
+  async members(id) {
+    return this.http.get(`organizations/${id}/members`).json();
+  }
+  /**
+   * Invite a member (owner/admin only)
+   */
+  async invite(id, data) {
+    return this.http.post(`organizations/${id}/members/invite`, { json: data }).json();
+  }
+  /**
+   * Remove a member (owner/admin only)
+   */
+  async removeMember(id, memberId) {
+    await this.http.delete(`organizations/${id}/members/${memberId}`);
+  }
+  /**
+   * Update member role (owner/admin only)
+   */
+  async updateMemberRole(id, memberId, data) {
+    return this.http.put(`organizations/${id}/members/${memberId}/role`, { json: data }).json();
+  }
+  /**
+   * Get pending invitations
+   */
+  async invites(id) {
+    return this.http.get(`organizations/${id}/invites`).json();
+  }
+  /**
+   * Cancel a pending invitation (owner/admin only)
+   */
+  async cancelInvite(id, inviteId) {
+    await this.http.delete(`organizations/${id}/invites/${inviteId}`);
+  }
+};
+
+// src/resources/products.ts
+var ProductsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List products for an organization, with optional filters
+   */
+  async list(organizationId, filters) {
+    const searchParams = {};
+    if (filters?.description) searchParams.description = filters.description;
+    if (filters?.sku) searchParams.sku = filters.sku;
+    if (filters?.productKey !== void 0)
+      searchParams.productKey = String(filters.productKey);
+    return this.http.get(`organizations/${organizationId}/products`, {
+      searchParams: Object.keys(searchParams).length > 0 ? searchParams : void 0
+    }).json();
+  }
+  /**
+   * Get a product by ID
+   */
+  async get(organizationId, productId) {
+    return this.http.get(`organizations/${organizationId}/products/${productId}`).json();
+  }
+  /**
+   * Create a new product or service
+   */
+  async create(organizationId, data) {
+    return this.http.post(`organizations/${organizationId}/products`, { json: data }).json();
+  }
+  /**
+   * Update a product
+   */
+  async update(organizationId, productId, data) {
+    return this.http.put(`organizations/${organizationId}/products/${productId}`, {
+      json: data
+    }).json();
+  }
+  /**
+   * Delete a product
+   */
+  async delete(organizationId, productId) {
+    await this.http.delete(
+      `organizations/${organizationId}/products/${productId}`
+    );
+  }
+};
+
+// src/resources/users.ts
+var UsersResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get the currently authenticated user
+   */
+  async me() {
+    return this.http.get("users/me").json();
+  }
+  /**
+   * Get user by ID (requires read:user scope)
+   */
+  async getById(id) {
+    return this.http.get(`users/${id}`).json();
+  }
+  /**
+   * Get organizations for a user (requires read:organization scope)
+   */
+  async getOrganizations(id) {
+    return this.http.get(`users/${id}/organizations`).json();
+  }
+  /**
+   * Get user by email (requires read:user scope)
+   */
+  async getByEmail(email) {
+    return this.http.get(`users/email/${encodeURIComponent(email)}`).json();
+  }
+};
+
+// src/resources/webhooks.ts
+var WebhooksResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List all webhooks for an organization
+   */
+  async list(organizationId) {
+    return this.http.get(`organizations/${organizationId}/webhooks`).json();
+  }
+  /**
+   * Get webhook by ID
+   */
+  async get(organizationId, webhookId) {
+    return this.http.get(`organizations/${organizationId}/webhooks/${webhookId}`).json();
+  }
+  /**
+   * Create a new webhook
+   */
+  async create(organizationId, data) {
+    return this.http.post(`organizations/${organizationId}/webhooks`, { json: data }).json();
+  }
+  /**
+   * Update webhook
+   */
+  async update(organizationId, webhookId, data) {
+    return this.http.put(`organizations/${organizationId}/webhooks/${webhookId}`, {
+      json: data
+    }).json();
+  }
+  /**
+   * Delete webhook
+   */
+  async delete(organizationId, webhookId) {
+    await this.http.delete(
+      `organizations/${organizationId}/webhooks/${webhookId}`
+    );
+  }
+  /**
+   * Get webhook delivery history
+   */
+  async deliveries(organizationId, webhookId) {
+    return this.http.get(`organizations/${organizationId}/webhooks/${webhookId}/deliveries`).json();
+  }
+  /**
+   * Send test webhook
+   */
+  async test(organizationId, webhookId) {
+    return this.http.post(`organizations/${organizationId}/webhooks/${webhookId}/test`).json();
+  }
+};
+
+// src/client.ts
+var Timbrix = class {
+  http;
+  authStrategy;
+  auth;
+  organizations;
+  webhooks;
+  apiKeys;
+  users;
+  customers;
+  oauth;
+  products;
+  constructor(config = {}) {
+    const baseUrl = config.baseUrl || "http://localhost:3001/api";
+    if (config.bearerToken) {
+      this.authStrategy = new BearerAuth(config.bearerToken);
+    } else if (config.apiKey) {
+      this.authStrategy = new ApiKeyAuth(config.apiKey);
+    }
+    this.http = import_ky.default.create({
+      prefixUrl: baseUrl,
+      headers: {
+        "Content-Type": "application/json"
+      },
+      hooks: {
+        beforeRequest: [
+          (request) => {
+            if (this.authStrategy) {
+              const authHeaders = this.authStrategy.getHeaders();
+              Object.entries(authHeaders).forEach(([key, value]) => {
+                request.headers.set(key, value);
+              });
+            }
+          }
+        ]
+      }
+    });
+    this.auth = new AuthResource(this.http);
+    this.organizations = new OrganizationsResource(this.http);
+    this.webhooks = new WebhooksResource(this.http);
+    this.apiKeys = new ApiKeysResource(this.http);
+    this.users = new UsersResource(this.http);
+    this.customers = new CustomersResource(this.http);
+    this.oauth = new OAuthResource(this.http);
+    this.products = new ProductsResource(this.http);
+  }
+  /**
+   * Update authentication strategy (useful for CLI when token changes)
+   */
+  setAuth(bearerToken, apiKey) {
+    if (bearerToken) {
+      this.authStrategy = new BearerAuth(bearerToken);
+    } else if (apiKey) {
+      this.authStrategy = new ApiKeyAuth(apiKey);
+    } else {
+      this.authStrategy = void 0;
+    }
+  }
+  /**
+   * Make a custom request
+   */
+  async request(url, options) {
+    return this.http(url, options).json();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiKeyAuth,
+  ApiKeysResource,
+  AuthResource,
+  BearerAuth,
+  CustomersResource,
+  OAuthResource,
+  OrganizationsResource,
+  ProductsResource,
+  Timbrix,
+  UsersResource,
+  WebhooksResource
+});