@rewritejs/sdk 1.0.0

package/README.md

@@ -0,0 +1,178 @@
+<div align="center">
+
+# Rewrite Node SDK
+
+[`@rewritejs/sdk`](https://www.npmjs.com/package/@rewritejs/sdk), the official Node.js/TypeScript SDK for the Rewrite API.
+
+It wraps authentication, typed REST calls, and resource helpers on top of [`@rewritejs/rest`](https://www.npmjs.com/package/@rewritejs/rest) and [`@rewritejs/types`](https://www.npmjs.com/package/@rewritejs/types).
+
+## Installation
+
+Use your preferred package manager:
+
+</div>
+
+```bash
+bun add @rewritejs/sdk
+# Or
+npm install @rewritejs/sdk
+# Or
+pnpm add @rewritejs/sdk
+# Or
+yarn add @rewritejs/sdk
+```
+
+<div align="center">
+
+## Quick Start
+
+</div>
+
+```ts
+import { Rewrite } from '@rewritejs/sdk';
+
+const rewrite = new Rewrite(process.env.REWRITE_API_KEY!);
+
+const project = await rewrite.projects.get('123456789012345678');
+
+console.log({ project });
+```
+
+<div align="center">
+
+## Create The Client
+
+You can pass the API key directly or use the full options object.
+
+</div>
+
+```ts
+import { Rewrite } from '@rewritejs/sdk';
+
+const advanced = new Rewrite({
+	secret: 'rw_live_xxx',
+	rest: {
+		timeout: 10_000,
+		headers: {
+			'x-trace-id': 'my-service',
+		},
+		retry: {
+			max: 3,
+			delay: (attempt) => attempt * 250,
+		},
+	},
+});
+```
+
+<div align="center">
+
+### Projects
+
+</div>
+
+```ts
+const project = await rewrite.projects.create({ name: 'AbacatePay Notifications' });
+
+console.log({ project });
+```
+
+<div align="center">
+
+### Templates
+
+</div>
+
+```ts
+const project = '123456789012345678';
+
+const created = await rewrite.templates.create({
+	project,
+	name: 'welcome_sms',
+	content: 'Hey {{name}}, welcome to {{company}}!',
+	variables: [
+		{ name: 'name', fallback: 'customer' },
+		{ name: 'company', fallback: 'Rewrite' },
+	],
+});
+
+const templates = await rewrite.templates.list(project, { limit: 20 });
+
+console.log({ templates });
+```
+
+<div align="center">
+
+### Webhooks
+
+</div>
+
+```ts
+import { WebhookEventType, WebhookStatus } from '@rewritejs/types';
+
+const project = '123456789012345678';
+
+const hook = await rewrite.webhooks.create({
+	project,
+	name: 'delivery-events',
+	endpoint: 'https://example.com/rewrite/webhooks',
+	events: [WebhookEventType.SMSDelivered, WebhookEventType.SMSFailed],
+});
+
+await rewrite.webhooks.update(hook.data.id, {
+	project,
+	status: WebhookStatus.Inactive,
+});
+
+const hooks = await rewrite.webhooks.list(project, { limit: 10 });
+
+console.log({ hooks });
+```
+
+<div align="center">
+
+### API Keys
+
+</div>
+
+```ts
+import { APIKeyScope } from '@rewritejs/types';
+
+const project = '123456789012345678';
+
+const key = await rewrite.apiKeys.create({
+	project,
+	name: 'backend-prod',
+	scopes: [APIKeyScope.ReadProject, APIKeyScope.ReadTemplates],
+});
+
+console.log({ key });
+```
+
+<div align="center">
+
+## Error Handling
+
+Requests run through `@rewritejs/rest`. HTTP failures can throw `HTTPError`.
+
+</div>
+
+```ts
+import { HTTPError } from '@rewritejs/rest';
+
+try {
+	await rewrite.projects.get('invalid_id');
+} catch (error) {
+	if (error instanceof HTTPError) {
+		console.error('HTTP Error:', error.status, error.method, error.url);
+	}
+}
+```
+
+<div align="center">
+
+---
+
+Made with 🤍 by the Rewrite team. <br/>
+SMS the way it should be.
+
+</div>

package/dist/client.d.ts

@@ -0,0 +1,27 @@
+import { REST } from '@rewritejs/rest';
+import { APIKeys } from './resources/apiKeys';
+import { Projects } from './resources/projects';
+import { Templates } from './resources/templates';
+import { Webhooks } from './resources/webhooks';
+import type { RewriteOptions } from './types';
+/**
+ * Main SDK client for the Rewrite API.
+ */
+export declare class Rewrite {
+    /** Low-level REST client instance. */
+    readonly rest: REST;
+    /** Resolved API secret used for authentication. */
+    private readonly secret;
+    /** API keys resource client. */
+    readonly apiKeys: APIKeys;
+    /** Projects resource client. */
+    readonly projects: Projects;
+    /** Templates resource client. */
+    readonly templates: Templates;
+    /** Webhooks resource client. */
+    readonly webhooks: Webhooks;
+    /**
+     * Creates a new Rewrite client instance.
+     */
+    constructor(options: RewriteOptions | string);
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { Rewrite } from './client';
+export * from './types';
+export { version } from './version';

package/dist/index.js

@@ -0,0 +1,313 @@
+// node_modules/@rewritejs/rest/dist/errors.js
+class HTTPError extends Error {
+  message;
+  status;
+  url;
+  method;
+  constructor(message, status, url, method) {
+    super(message);
+    this.message = message;
+    this.status = status;
+    this.url = url;
+    this.method = method;
+    this.name = `HTTPError(${status})`;
+  }
+}
+
+// node_modules/@rewritejs/rest/dist/utils.js
+var createURL = (route, query, baseURL = "https://api.userewrite.me") => {
+  const url = `${baseURL}/v1${route}`;
+  return query ? `${url}?${new URLSearchParams(query)}` : url;
+};
+var FIVE_SECONDS_IN_MS = 5000;
+var RETRYABLE_STATUS = [408, 425, 429, 500, 502, 503, 504];
+var isRetryableStatus = (status) => RETRYABLE_STATUS.includes(status);
+var BASE_DELAY_MS = 300;
+var MAX_DELAY_MS = 1e4;
+var backoff = (attempt) => {
+  const exp = Math.min(MAX_DELAY_MS, BASE_DELAY_MS * 2 ** attempt);
+  const jitter = Math.random() * exp * 0.3;
+  return Math.floor(exp + jitter);
+};
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+// node_modules/@rewritejs/rest/dist/client.js
+class REST {
+  options;
+  headers = { "Content-Type": "application/json" };
+  constructor(options) {
+    this.options = typeof options === "string" ? { auth: options } : options;
+    this.headers = {
+      ...this.options.headers,
+      Authorization: `Bearer ${this.options.auth}`
+    };
+  }
+  setAuth(authorization) {
+    this.options.auth = authorization;
+    this.headers.Authorization = `Bearer ${authorization}`;
+    return this;
+  }
+  get(route, options) {
+    return this.fetch(route, { ...options, method: "GET" });
+  }
+  post(route, data, options) {
+    return this.fetch(route, { data, ...options, method: "POST" });
+  }
+  delete(route, options) {
+    return this.fetch(route, { ...options, method: "DELETE" });
+  }
+  put(route, options) {
+    return this.fetch(route, { ...options, method: "PUT" });
+  }
+  patch(route, data, options) {
+    return this.fetch(route, { data, ...options, method: "PATCH" });
+  }
+  async fetch(route, options, attempt = 0) {
+    const response = await this.createRequest(route, options);
+    if (!response.ok)
+      return this.handleError({
+        route,
+        attempt,
+        options,
+        response,
+        method: options.method
+      });
+    const { data } = await response.json();
+    return data;
+  }
+  async handleError({ route, method, options, attempt, response }) {
+    if (!isRetryableStatus(response.status)) {
+      const { error } = await response.json();
+      throw new HTTPError(error, response.status, response.url, method);
+    }
+    const { retry } = this.options;
+    if (attempt >= (retry?.max ?? 3))
+      throw new HTTPError("Max retries reached", response.status, response.url, method);
+    if (retry?.onRetry)
+      await retry.onRetry({ route, attempt, options, response, method });
+    const delay = (retry?.delay ?? backoff)(attempt);
+    await sleep(delay);
+    return this.fetch(route, options, attempt + 1);
+  }
+  createRequest(route, options) {
+    const timeout = options.timeout ?? this.options.timeout ?? FIVE_SECONDS_IN_MS;
+    const url = createURL(route, options.query, this.options.baseURL);
+    return fetch(url, {
+      method: options.method,
+      signal: AbortSignal.timeout(timeout),
+      headers: { ...this.headers, ...options.headers },
+      body: "data" in options ? JSON.stringify(options.data) : null
+    });
+  }
+}
+// node_modules/@rewritejs/types/dist/v1/resources/apiKeys.js
+var APIKeyScope;
+(function(APIKeyScope2) {
+  APIKeyScope2["Wildcard"] = "*";
+  APIKeyScope2["ReadProject"] = "project:read";
+  APIKeyScope2["WriteProject"] = "project:write";
+  APIKeyScope2["ReadAPIKeys"] = "project:api_key:read";
+  APIKeyScope2["WriteTemplate"] = "project:template:write";
+  APIKeyScope2["ReadTemplates"] = "project:template:read";
+  APIKeyScope2["ReadPayments"] = "project:payment:read";
+  APIKeyScope2["ReadWebhooks"] = "project:webhook:read";
+  APIKeyScope2["WriteWebhooks"] = "project:webhook:write";
+})(APIKeyScope || (APIKeyScope = {}));
+// node_modules/@rewritejs/types/dist/v1/resources/webhooks.js
+var WebhookEventType;
+(function(WebhookEventType2) {
+  WebhookEventType2["SMSQueued"] = "sms.queued";
+  WebhookEventType2["SMSDelivered"] = "sms.delivered";
+  WebhookEventType2["SMSScheduled"] = "sms.scheduled";
+  WebhookEventType2["SMSFailed"] = "sms.failed";
+  WebhookEventType2["SMSCanceled"] = "sms.canceled";
+})(WebhookEventType || (WebhookEventType = {}));
+var WebhookStatus;
+(function(WebhookStatus2) {
+  WebhookStatus2["Active"] = "ACTIVE";
+  WebhookStatus2["Inactive"] = "INACTIVE";
+})(WebhookStatus || (WebhookStatus = {}));
+// node_modules/@rewritejs/types/dist/v1/utils.js
+var createCursorQuery = ({ limit = 15, ...options } = {}) => {
+  return new URLSearchParams({ limit: limit.toString(), ...options });
+};
+
+// node_modules/@rewritejs/types/dist/v1/routes.js
+var Routes = {
+  webhooks: {
+    list(id, options) {
+      return `/projects/${id}/webhooks?${createCursorQuery(options)}`;
+    },
+    create(id) {
+      return `/projects/${id}/webhooks`;
+    },
+    update(id, webhookId) {
+      return `/projects/${id}/webhooks/${webhookId}`;
+    },
+    delete(id, webhookId) {
+      return `/projects/${id}/webhooks/${webhookId}`;
+    },
+    get(id, webhookId) {
+      return `/projects/${id}/webhooks/${webhookId}`;
+    }
+  },
+  templates: {
+    list(id, options) {
+      return `/projects/${id}/templates?${createCursorQuery(options)}`;
+    },
+    create(id) {
+      return `/projects/${id}/templates`;
+    },
+    update(id, templateId) {
+      return `/projects/${id}/templates/${templateId}`;
+    },
+    delete(id, templateId) {
+      return `/projects/${id}/templates/${templateId}`;
+    },
+    get(id, templateId) {
+      return `/projects/${id}/templates/${templateId}`;
+    }
+  },
+  apiKeys: {
+    list(id, options) {
+      return `/projects/${id}/api-keys?${createCursorQuery(options)}`;
+    },
+    create(id) {
+      return `/projects/${id}/api-keys`;
+    },
+    delete(id, apiKeyId) {
+      return `/projects/${id}/api-keys/${apiKeyId}`;
+    }
+  },
+  projects: {
+    create() {
+      return `/projects`;
+    },
+    update(id) {
+      return `/projects/${id}`;
+    },
+    delete(id) {
+      return `/projects/${id}`;
+    },
+    get(id) {
+      return `/projects/${id}`;
+    }
+  }
+};
+// src/resources/base.ts
+class Base {
+  rest;
+  constructor(rest2) {
+    this.rest = rest2;
+  }
+}
+
+// src/resources/apiKeys.ts
+class APIKeys extends Base {
+  async create(options) {
+    const data = await this.rest.post(Routes.apiKeys.create(options.project), options);
+    return data;
+  }
+  async delete(id, project) {
+    await this.rest.delete(Routes.apiKeys.delete(project, id));
+  }
+  async list(project, query) {
+    const data = await this.rest.get(Routes.apiKeys.list(project, query));
+    return data;
+  }
+}
+
+// src/resources/projects.ts
+class Projects extends Base {
+  async create(options) {
+    const data = await this.rest.post(Routes.projects.create(), options);
+    return data;
+  }
+  async update(id, options) {
+    const data = await this.rest.patch(Routes.projects.update(id), options);
+    return data;
+  }
+  async delete(id) {
+    await this.rest.delete(Routes.projects.delete(id));
+  }
+  async get(id) {
+    const data = await this.rest.get(Routes.projects.get(id));
+    return data;
+  }
+}
+
+// src/resources/templates.ts
+class Templates extends Base {
+  async create(options) {
+    const data = await this.rest.post(Routes.templates.create(options.project), options);
+    return data;
+  }
+  async update(id, options) {
+    const data = await this.rest.patch(Routes.templates.update(options.project, id), options);
+    return data;
+  }
+  async delete(id, project) {
+    await this.rest.delete(Routes.templates.delete(project, id));
+  }
+  async list(project, query) {
+    const data = await this.rest.get(Routes.templates.list(project, query));
+    return data;
+  }
+  async get(id, project) {
+    const data = await this.rest.get(Routes.templates.get(project, id));
+    return data;
+  }
+}
+
+// src/resources/webhooks.ts
+class Webhooks extends Base {
+  async create(options) {
+    const data = await this.rest.post(Routes.webhooks.create(options.project), options);
+    return data;
+  }
+  async update(id, options) {
+    const data = await this.rest.patch(Routes.webhooks.update(options.project, id), options);
+    return data;
+  }
+  async delete(id, project) {
+    await this.rest.delete(Routes.webhooks.delete(project, id));
+  }
+  async list(project, query) {
+    const data = await this.rest.get(Routes.webhooks.list(project, query));
+    return data;
+  }
+  async get(id, project) {
+    const data = await this.rest.get(Routes.webhooks.get(project, id));
+    return data;
+  }
+}
+
+// src/client.ts
+class Rewrite {
+  rest;
+  secret;
+  apiKeys;
+  projects;
+  templates;
+  webhooks;
+  constructor(options) {
+    const resolved = typeof options === "string" ? { secret: options } : options;
+    if (typeof resolved.secret !== "string")
+      throw new Error("Expected a string for the secret");
+    this.secret = resolved.secret;
+    this.rest = new REST({
+      ...resolved.rest,
+      auth: this.secret
+    });
+    this.apiKeys = new APIKeys(this.rest);
+    this.projects = new Projects(this.rest);
+    this.templates = new Templates(this.rest);
+    this.webhooks = new Webhooks(this.rest);
+  }
+}
+// src/version.ts
+var version = "1.0.0";
+export {
+  version,
+  Rewrite
+};

package/dist/resources/apiKeys.d.ts

@@ -0,0 +1,21 @@
+import { type RESTGetListAPIKeysData, type RESTGetListAPIKeysQueryParams, type RESTPostCreateAPIKeyBody, type RESTPostCreateAPIKeyData } from '@rewritejs/types';
+import { Base } from './base';
+/**
+ * API key resource operations.
+ */
+export declare class APIKeys extends Base {
+    /**
+     * Creates an API key for a project.
+     */
+    create(options: RESTPostCreateAPIKeyBody & {
+        project: string;
+    }): Promise<RESTPostCreateAPIKeyData>;
+    /**
+     * Deletes an API key by id.
+     */
+    delete(id: string, project: string): Promise<void>;
+    /**
+     * Lists API keys for a project.
+     */
+    list(project: string, query?: RESTGetListAPIKeysQueryParams): Promise<RESTGetListAPIKeysData>;
+}

package/dist/resources/base.d.ts

@@ -0,0 +1,12 @@
+import type { REST } from '@rewritejs/rest';
+/**
+ * Shared base resource with access to the REST client.
+ */
+export declare abstract class Base {
+    /** REST client used by resource operations. */
+    readonly rest: REST;
+    /**
+     * Creates a base resource wrapper.
+     */
+    constructor(rest: REST);
+}

package/dist/resources/projects.d.ts

@@ -0,0 +1,23 @@
+import { type RESTGetProjectData, type RESTPatchUpdateProjectBody, type RESTPatchUpdateProjectData, type RESTPostCreateProjectBody, type RESTPostCreateProjectData } from '@rewritejs/types';
+import { Base } from './base';
+/**
+ * Project resource operations.
+ */
+export declare class Projects extends Base {
+    /**
+     * Creates a new project.
+     */
+    create(options: RESTPostCreateProjectBody): Promise<RESTPostCreateProjectData>;
+    /**
+     * Updates a project by id.
+     */
+    update(id: string, options: RESTPatchUpdateProjectBody): Promise<RESTPatchUpdateProjectData>;
+    /**
+     * Deletes a project by id.
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * Fetches a project by id.
+     */
+    get(id: string): Promise<RESTGetProjectData>;
+}

package/dist/resources/templates.d.ts

@@ -0,0 +1,31 @@
+import { type RESTGetListTemplatesData, type RESTGetListTemplatesQueryParams, type RESTGetTemplateData, type RESTPostCreateTemplateBody, type RESTPostCreateTemplateData } from '@rewritejs/types';
+import { Base } from './base';
+/**
+ * Template resource operations.
+ */
+export declare class Templates extends Base {
+    /**
+     * Creates a template for a project.
+     */
+    create(options: RESTPostCreateTemplateBody & {
+        project: string;
+    }): Promise<RESTPostCreateTemplateData>;
+    /**
+     * Updates a template by id.
+     */
+    update(id: string, options: RESTPostCreateTemplateBody & {
+        project: string;
+    }): Promise<RESTPostCreateTemplateData>;
+    /**
+     * Deletes a template by id.
+     */
+    delete(id: string, project: string): Promise<void>;
+    /**
+     * Lists templates for a project.
+     */
+    list(project: string, query?: RESTGetListTemplatesQueryParams): Promise<RESTGetListTemplatesData>;
+    /**
+     * Fetches a template by id.
+     */
+    get(id: string, project: string): Promise<RESTGetTemplateData>;
+}

package/dist/resources/webhooks.d.ts

@@ -0,0 +1,31 @@
+import { type RESTGetListWebhooksData, type RESTGetListWebhooksQueryParams, type RESTGetWebhookData, type RESTPatchUpdateWebhookBody, type RESTPatchUpdateWebhookData, type RESTPostCreateWebhookBody, type RESTPostCreateWebhookData } from '@rewritejs/types';
+import { Base } from './base';
+/**
+ * Webhook resource operations.
+ */
+export declare class Webhooks extends Base {
+    /**
+     * Creates a webhook for a project.
+     */
+    create(options: RESTPostCreateWebhookBody & {
+        project: string;
+    }): Promise<RESTPostCreateWebhookData>;
+    /**
+     * Updates a webhook by id.
+     */
+    update(id: string, options: RESTPatchUpdateWebhookBody & {
+        project: string;
+    }): Promise<RESTPatchUpdateWebhookData>;
+    /**
+     * Deletes a webhook by id.
+     */
+    delete(id: string, project: string): Promise<void>;
+    /**
+     * Lists webhooks for a project.
+     */
+    list(project: string, query?: RESTGetListWebhooksQueryParams): Promise<RESTGetListWebhooksData>;
+    /**
+     * Fetches a webhook by id.
+     */
+    get(id: string, project: string): Promise<RESTGetWebhookData>;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,10 @@
+import type { RESTOptions } from '@rewritejs/rest';
+/**
+ * Options used to initialize the Rewrite client.
+ */
+export interface RewriteOptions {
+    /** API secret used for authentication. */
+    secret: string;
+    /** Extra REST client options, excluding auth. */
+    rest?: Omit<RESTOptions, 'auth'>;
+}

package/dist/version.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Current version of [@rewritejs/sdk](https://www.npmjs.com/package/@rewritejs/sdk).
+ */
+export declare const version: "1.0.0";

package/package.json

@@ -0,0 +1,48 @@
+{
+	"name": "@rewritejs/sdk",
+	"module": "src/index.ts",
+	"type": "module",
+	"private": false,
+	"version": "1.0.0",
+	"devDependencies": {
+		"@biomejs/biome": "^2.4.2",
+		"@types/bun": "latest"
+	},
+	"peerDependencies": {
+		"typescript": "^5"
+	},
+	"dependencies": {
+		"@rewritejs/rest": "^1.0.1",
+		"@rewritejs/types": "^1.0.0"
+	},
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"files": [
+		"dist"
+	],
+	"maintainers": [
+		{
+			"name": "Almeida",
+			"url": "https://github.com/almeidazs"
+		}
+	],
+	"scripts": {
+		"test": "bun test",
+		"biome:check": "biome check --write .",
+		"build": "rm -rf dist && bun run scripts/version.ts && bun biome:check && bun build src/index.ts --outdir dist --target node && bun run types",
+		"types": "bunx tsc --emitDeclarationOnly",
+		"prepublishOnly": "bun run build"
+	},
+	"engines": {
+		"node": ">=18",
+		"bun": ">=1.0.0"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/rewritetoday/node.git"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"description": "An ergonomic SDK to integrate with Rewrite in your workflow"
+}