@wtfalch/agreements 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 William Tallis Falch
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,34 @@
+# @wtfalch/agreements
+
+Public client SDK and API types for the Agreements service. Requires Node 22+ or a
+browser with Fetch support. The client has no runtime package dependencies.
+
+## Status
+
+Published: no.
+
+```sh
+npm install @wtfalch/agreements
+```
+
+```ts
+import { createAgreementsClient } from '@wtfalch/agreements';
+
+const agreements = createAgreementsClient({
+  baseUrl: serviceOrigin,
+  credential: () => serviceKey,
+});
+
+const agreements = await agreements.createAgreements({ organisationId, name: 'Widget' });
+const { agreements: list } = await agreements.listAgreements(organisationId);
+```
+
+The credential callback runs for every request, so rotation does not require a
+new client. API failures reject with `AgreementsApiError`, which carries `status`
+and a typed `code` (see `AgreementsError`); the SDK never throws a bare `Error`
+for a service failure.
+
+The root export provides the client and public request/response types.
+`@wtfalch/agreements/client` is also supported. There are no server, database,
+migration or authorization exports. The service implementation is a private
+package.

package/dist/client.d.ts

@@ -0,0 +1,7 @@
+import { type ClientOptions } from './transport.js';
+import type { Agreements, CreateAgreementsRequest, ListAgreementsResponse } from './types.js';
+export { AgreementsApiError, type ClientOptions } from './transport.js';
+export declare function createAgreementsClient(options: ClientOptions): {
+    createAgreements: (input: CreateAgreementsRequest) => Promise<Agreements>;
+    listAgreements: (organisationId: string) => Promise<ListAgreementsResponse>;
+};

package/dist/client.js

@@ -0,0 +1,9 @@
+import { createTransport } from './transport.js';
+export { AgreementsApiError } from './transport.js';
+export function createAgreementsClient(options) {
+    const call = createTransport(options);
+    return {
+        createAgreements: (input) => call('POST', '/v1/agreements', input),
+        listAgreements: (organisationId) => call('GET', `/v1/agreements?${new URLSearchParams({ organisationId })}`),
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './client.js';
+export type * from './types.js';

package/dist/index.js

@@ -0,0 +1 @@
+export * from './client.js';

package/dist/transport.d.ts

@@ -0,0 +1,16 @@
+import type { AgreementsErrorCode } from './types.js';
+export interface ClientOptions {
+    baseUrl: string;
+    credential: () => string | Promise<string>;
+    fetch?: typeof fetch;
+}
+/** A typed failure, never a bare `Error`. `status` is the HTTP status; `code`
+ * and `message` are the service's own wire error (see `AgreementsError`). */
+export declare class AgreementsApiError extends Error {
+    readonly status: number;
+    readonly code: AgreementsErrorCode;
+    constructor(status: number, code: AgreementsErrorCode, message: string);
+}
+/** Minimal fetch-based transport: JSON in, JSON out, a bearer credential on
+ * every request. No Node-only imports -- this runs in a browser too. */
+export declare function createTransport(options: ClientOptions): <T>(method: string, path: string, input?: unknown) => Promise<T>;

package/dist/transport.js

@@ -0,0 +1,63 @@
+const KNOWN_CODES = [
+    'invalid_request',
+    'unauthorized',
+    'forbidden',
+    'not_found',
+    'unavailable',
+];
+/** A typed failure, never a bare `Error`. `status` is the HTTP status; `code`
+ * and `message` are the service's own wire error (see `AgreementsError`). */
+export class AgreementsApiError extends Error {
+    status;
+    code;
+    constructor(status, code, message) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.name = 'AgreementsApiError';
+    }
+}
+function errorFrom(value) {
+    const error = typeof value === 'object' && value !== null && 'error' in value
+        ? value.error
+        : null;
+    const rawCode = typeof error === 'object' && error !== null && 'code' in error && typeof error.code === 'string'
+        ? error.code
+        : undefined;
+    const rawMessage = typeof error === 'object' &&
+        error !== null &&
+        'message' in error &&
+        typeof error.message === 'string'
+        ? error.message
+        : undefined;
+    const code = KNOWN_CODES.includes(rawCode ?? '')
+        ? rawCode
+        : 'unavailable';
+    return { code, message: rawMessage ?? 'Request failed' };
+}
+/** Minimal fetch-based transport: JSON in, JSON out, a bearer credential on
+ * every request. No Node-only imports -- this runs in a browser too. */
+export function createTransport(options) {
+    return async (method, path, input) => {
+        const response = await (options.fetch ?? fetch)(new URL(path, options.baseUrl), {
+            method,
+            headers: {
+                authorization: `Bearer ${await options.credential()}`,
+                ...(input === undefined ? {} : { 'content-type': 'application/json' }),
+            },
+            body: input === undefined ? undefined : JSON.stringify(input),
+        });
+        let value;
+        try {
+            value = response.status === 204 ? undefined : await response.json();
+        }
+        catch {
+            throw new AgreementsApiError(response.status, 'unavailable', 'Invalid response body');
+        }
+        if (!response.ok) {
+            const { code, message } = errorFrom(value);
+            throw new AgreementsApiError(response.status, code, message);
+        }
+        return value;
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,33 @@
+/** Public HTTP contracts for the Agreements service. Internal storage rows are never returned. */
+export interface Agreements {
+    id: string;
+    organisationId: string;
+    name: string;
+    createdAt: string;
+}
+export interface CreateAgreementsRequest {
+    organisationId: string;
+    name: string;
+}
+export interface ListAgreementsResponse {
+    agreements: Agreements[];
+}
+/** The wire shape of a failed request, discriminated on `code` so a caller can
+ * narrow on it. Every non-2xx response body has this shape. */
+export type AgreementsError = {
+    code: 'invalid_request';
+    message: string;
+} | {
+    code: 'unauthorized';
+    message: string;
+} | {
+    code: 'forbidden';
+    message: string;
+} | {
+    code: 'not_found';
+    message: string;
+} | {
+    code: 'unavailable';
+    message: string;
+};
+export type AgreementsErrorCode = AgreementsError['code'];

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@wtfalch/agreements",
+  "version": "0.1.0",
+  "type": "module",
+  "license": "MIT",
+  "description": "Public client SDK and API types for the Agreements service.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/wtfalch/agreements",
+    "directory": "packages/sdk"
+  },
+  "files": [
+    "LICENSE",
+    "README.md",
+    "dist/client.d.ts",
+    "dist/client.js",
+    "dist/index.d.ts",
+    "dist/index.js",
+    "dist/transport.d.ts",
+    "dist/transport.js",
+    "dist/types.d.ts",
+    "dist/types.js"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "default": "./dist/client.js"
+    }
+  },
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "prepublishOnly": "pnpm build && node ../../scripts/check-package.mjs"
+  },
+  "devDependencies": {
+    "@types/node": "^22",
+    "typescript": "^5.9.0",
+    "vitest": "^4.1.6"
+  }
+}