@avenlabs/halal-trace-sdk 0.1.1

package/dist/client.js

@@ -0,0 +1,358 @@
+import { ApiError, request, requestRaw } from "./http.js";
+const sdkVersion = "0.1.0";
+const withDefaults = (client, options = {}) => {
+    return {
+        ...options,
+        timeoutMs: options.timeoutMs ?? client.timeoutMs,
+        allowInsecure: options.allowInsecure ?? client.allowInsecure,
+        retry: options.retry ?? client.retry,
+        auth: options.auth ?? client.authOptions,
+        onAuthError: options.onAuthError ?? client.onAuthError,
+        sdkHeaders: {
+            "x-sdk-name": "@halal-trace/sdk",
+            "x-sdk-version": sdkVersion,
+            ...(client.clientVersion ? { "x-client-version": client.clientVersion } : {}),
+            ...(client.userAgent ? { "User-Agent": client.userAgent } : {}),
+        },
+        hooks: client.hooks,
+        signingHook: client.signingHook,
+    };
+};
+const unwrap = (response) => response.data ?? undefined;
+async function* listPaginated(client, path, query) {
+    const limit = query?.limit ?? 50;
+    let offset = 0;
+    while (true) {
+        const response = await client.request("GET", path, { query: { ...query, limit, offset }, canRetry: true });
+        const items = response.body.data ?? [];
+        for (const item of items) {
+            yield item;
+        }
+        if (items.length < limit) {
+            break;
+        }
+        offset += limit;
+    }
+}
+async function* listSingle(client, path, query) {
+    const response = await client.request("GET", path, { query, canRetry: true });
+    const items = response.body.data ?? [];
+    for (const item of items) {
+        yield item;
+    }
+}
+async function* listRelayerJobsAll(client, orgId, query) {
+    const limit = query?.limit ?? 100;
+    let offset = 0;
+    while (true) {
+        const response = await client.orgs.listRelayerJobs(orgId, { ...query, limit, offset });
+        const items = response.data ?? [];
+        for (const item of items) {
+            yield item;
+        }
+        if (items.length < limit) {
+            break;
+        }
+        offset += limit;
+    }
+}
+export class ApiClient {
+    baseUrl;
+    timeoutMs;
+    headers;
+    authOptions;
+    retry;
+    allowInsecure;
+    onAuthError;
+    hooks;
+    userAgent;
+    clientVersion;
+    signingHook;
+    constructor(options) {
+        if (!options.baseUrl) {
+            throw new Error("baseUrl is required");
+        }
+        this.baseUrl = options.baseUrl;
+        this.timeoutMs = options.timeoutMs;
+        this.headers = options.headers;
+        this.authOptions = options.auth;
+        this.retry = options.retry;
+        this.allowInsecure = options.allowInsecure;
+        this.onAuthError = options.onAuthError;
+        this.hooks = options.hooks;
+        this.userAgent = options.userAgent;
+        this.clientVersion = options.clientVersion;
+        this.signingHook = options.signingHook;
+    }
+    async request(method, path, options = {}) {
+        const response = await request(this.baseUrl, path, method, {
+            ...withDefaults(this, options),
+            headers: {
+                ...(this.headers ?? {}),
+                ...(options.headers ?? {}),
+            },
+        });
+        return {
+            body: {
+                ...response.body,
+                requestId: response.requestId,
+            },
+            requestId: response.requestId,
+        };
+    }
+    health = {
+        get: async () => unwrap((await this.request("GET", "/health", { canRetry: true })).body),
+        live: async () => unwrap((await this.request("GET", "/live", { canRetry: true })).body),
+        ready: async () => unwrap((await this.request("GET", "/ready", { canRetry: true })).body),
+    };
+    system = {
+        docs: async () => {
+            const response = await requestRaw(this.baseUrl, "/docs", "GET", { ...withDefaults(this, {}), canRetry: true });
+            return response.body;
+        },
+        openApi: async () => {
+            const response = await requestRaw(this.baseUrl, "/docs/openapi.json", "GET", { ...withDefaults(this, {}), canRetry: true });
+            return response.body;
+        },
+        metrics: async () => {
+            const response = await requestRaw(this.baseUrl, "/metrics", "GET", { ...withDefaults(this, {}), canRetry: true });
+            return response.body;
+        },
+        inviteLanding: async (orgId, token) => {
+            const response = await requestRaw(this.baseUrl, "/invites/accept", "GET", {
+                ...withDefaults(this, {}),
+                query: { orgId, token },
+                canRetry: true,
+            });
+            return response.body;
+        },
+    };
+    auth = {
+        signUpEmail: async (payload, options) => {
+            const response = await requestRaw(this.baseUrl, "/api/auth/sign-up/email", "POST", {
+                ...withDefaults(this, options ?? {}),
+                body: payload,
+                canRetry: false,
+            });
+            return { data: response.body, token: response.headers.get("set-auth-token"), requestId: response.requestId };
+        },
+        signInEmail: async (payload, options) => {
+            const response = await requestRaw(this.baseUrl, "/api/auth/sign-in/email", "POST", {
+                ...withDefaults(this, options ?? {}),
+                body: payload,
+                canRetry: false,
+            });
+            return { data: response.body, token: response.headers.get("set-auth-token"), requestId: response.requestId };
+        },
+        verifyEmail: async (token, callbackURL) => {
+            const response = await requestRaw(this.baseUrl, "/api/auth/verify-email", "GET", {
+                ...withDefaults(this, {}),
+                query: { token, callbackURL },
+                canRetry: true,
+            });
+            return { data: response.body, token: response.headers.get("set-auth-token"), requestId: response.requestId };
+        },
+        requestPasswordReset: async (payload) => {
+            const response = await requestRaw(this.baseUrl, "/api/auth/request-password-reset", "POST", {
+                ...withDefaults(this, {}),
+                body: payload,
+                canRetry: false,
+            });
+            return { data: response.body, token: response.headers.get("set-auth-token"), requestId: response.requestId };
+        },
+        resetPassword: async (payload) => {
+            const response = await requestRaw(this.baseUrl, "/api/auth/reset-password", "POST", {
+                ...withDefaults(this, {}),
+                body: payload,
+                canRetry: false,
+            });
+            return { data: response.body, token: response.headers.get("set-auth-token"), requestId: response.requestId };
+        },
+    };
+    orgs = {
+        create: async (payload, options) => await this.request("POST", "/orgs", {
+            ...options,
+            body: payload,
+            canRetry: true,
+            idempotencyKey: options?.idempotencyKey,
+        }).then((res) => res.body),
+        addMember: async (orgId, payload, options) => await this.request("POST", `/orgs/${orgId}/members`, {
+            ...options,
+            body: payload,
+            canRetry: true,
+            idempotencyKey: options?.idempotencyKey,
+        }).then((res) => res.body),
+        updateMember: async (orgId, userId, payload) => await this.request("PATCH", `/orgs/${orgId}/members/${userId}`, { body: payload, canRetry: false }).then((res) => res.body),
+        removeMember: async (orgId, userId) => await this.request("DELETE", `/orgs/${orgId}/members/${userId}`, { canRetry: false }).then((res) => res.body),
+        listMembers: async (orgId) => await this.request("GET", `/orgs/${orgId}/members`, { canRetry: true }).then((res) => res.body),
+        listMembersAll: (orgId) => listSingle(this, `/orgs/${orgId}/members`),
+        listAuditLogs: async (orgId, query) => await this.request("GET", `/orgs/${orgId}/audit-logs`, { query, canRetry: true }).then((res) => res.body),
+        listAuditLogsAll: (orgId, query) => listPaginated(this, `/orgs/${orgId}/audit-logs`, query),
+        listRelayerJobs: async (orgId, query) => await this.request("GET", `/orgs/${orgId}/relayer-jobs`, { query, canRetry: true }).then((res) => res.body),
+        getRelayerJob: async (orgId, jobId) => await this.request("GET", `/orgs/${orgId}/relayer-jobs/${jobId}`, { canRetry: true }).then((res) => res.body),
+        listDeadRelayerJobs: async (orgId) => await this.request("GET", `/orgs/${orgId}/relayer-jobs/dead`, { canRetry: true }).then((res) => res.body),
+        retryRelayerJob: async (orgId, jobId) => await this.request("POST", `/orgs/${orgId}/relayer-jobs/${jobId}/retry`, { canRetry: false }).then((res) => res.body),
+        backfillOrg: async (orgId) => await this.request("POST", `/orgs/${orgId}/relayer-jobs/backfill`, { canRetry: false }).then((res) => res.body),
+        listInvites: async (orgId, query) => await this.request("GET", `/orgs/${orgId}/invites`, { query, canRetry: true }).then((res) => res.body),
+        listInvitesAll: (orgId, query) => listSingle(this, `/orgs/${orgId}/invites`, query),
+        inviteMember: async (orgId, payload, options) => await this.request("POST", `/orgs/${orgId}/invites`, {
+            ...options,
+            body: payload,
+            canRetry: true,
+            idempotencyKey: options?.idempotencyKey,
+        }).then((res) => res.body),
+        acceptInvite: async (orgId, token) => await this.request("POST", `/orgs/${orgId}/invites/${token}/accept`, { canRetry: false }).then((res) => res.body),
+        lookupUserByEmail: async (orgId, email) => await this.request("GET", `/orgs/${orgId}/users`, { query: { email }, canRetry: true }).then((res) => res.body),
+        listPermissions: async (orgId) => await this.request("GET", `/orgs/${orgId}/permissions`, { canRetry: true }).then((res) => res.body),
+        addPermission: async (orgId, payload) => await this.request("POST", `/orgs/${orgId}/permissions`, { body: payload, canRetry: false }).then((res) => res.body),
+        removePermission: async (orgId, payload) => await this.request("DELETE", `/orgs/${orgId}/permissions`, {
+            body: payload,
+            canRetry: false,
+        }).then((res) => res.body),
+        setEventDepartment: async (orgId, payload) => await this.request("POST", `/orgs/${orgId}/event-departments`, { body: payload, canRetry: false }).then((res) => res.body),
+    };
+    relayerJobs = {
+        listAll: (orgId, query) => listRelayerJobsAll(this, orgId, query),
+        get: async (orgId, jobId) => this.orgs.getRelayerJob(orgId, jobId).then((res) => res.data),
+        waitFor: async (orgId, jobId, options) => {
+            const timeoutMs = options?.timeoutMs ?? 60000;
+            const intervalMs = options?.intervalMs ?? 2000;
+            const start = Date.now();
+            while (Date.now() - start < timeoutMs) {
+                const job = await this.relayerJobs.get(orgId, jobId);
+                if (job && (job.status === "completed" || job.status === "dead" || job.status === "failed")) {
+                    return job;
+                }
+                await new Promise((resolve) => setTimeout(resolve, intervalMs));
+            }
+            throw new ApiError("Timeout waiting for relayer job");
+        },
+        waitForRequest: async (orgId, requestId, options) => {
+            const timeoutMs = options?.timeoutMs ?? 60000;
+            const intervalMs = options?.intervalMs ?? 2000;
+            const start = Date.now();
+            while (Date.now() - start < timeoutMs) {
+                const jobs = await this.orgs.listRelayerJobs(orgId, { requestId, limit: 10, offset: 0 });
+                const job = jobs.data?.[0];
+                if (job) {
+                    return job;
+                }
+                await new Promise((resolve) => setTimeout(resolve, intervalMs));
+            }
+            throw new ApiError("Timeout waiting for request relayer job");
+        },
+    };
+    batches = {
+        create: async (payload, options) => await this.request("POST", "/batches", {
+            ...options,
+            body: payload,
+            canRetry: true,
+            idempotencyKey: options?.idempotencyKey,
+        }).then((res) => res.body),
+        addPublicAttribute: async (batchId, payload, options) => await this.request("POST", `/batches/${batchId}/public-attributes`, {
+            ...options,
+            body: payload,
+            canRetry: true,
+            idempotencyKey: options?.idempotencyKey,
+        }).then((res) => res.body),
+        addEvent: async (batchId, payload, options) => await this.request("POST", `/batches/${batchId}/events`, {
+            ...options,
+            body: payload,
+            canRetry: Boolean(options?.idempotencyKey),
+            idempotencyKey: options?.idempotencyKey,
+        }).then((res) => res.body),
+        addDocument: async (batchId, payload, options) => await this.request("POST", `/batches/${batchId}/documents`, {
+            ...options,
+            body: payload,
+            canRetry: true,
+            idempotencyKey: options?.idempotencyKey,
+        }).then((res) => res.body),
+        addSignature: async (batchId, payload, options) => await this.request("POST", `/batches/${batchId}/signatures`, {
+            ...options,
+            body: payload,
+            canRetry: Boolean(options?.idempotencyKey),
+            idempotencyKey: options?.idempotencyKey,
+        }).then((res) => res.body),
+        addCertification: async (batchId, payload, options) => await this.request("POST", `/batches/${batchId}/certifications`, {
+            ...options,
+            body: payload,
+            canRetry: Boolean(options?.idempotencyKey),
+            idempotencyKey: options?.idempotencyKey,
+        }).then((res) => res.body),
+        getAuditPackManifest: async (batchId) => await this.request("GET", `/batches/${batchId}/audit-pack/manifest`, { canRetry: true }).then((res) => res.body),
+        listRelayerJobs: async (batchId, query) => await this.request("GET", `/batches/${batchId}/relayer-jobs`, { query, canRetry: true }).then((res) => res.body),
+        listRelayerJobsAll: (batchId, query) => listPaginated(this, `/batches/${batchId}/relayer-jobs`, query),
+        backfillBatch: async (batchId) => await this.request("POST", `/batches/${batchId}/relayer-jobs/backfill`, { canRetry: false }).then((res) => res.body),
+    };
+    devices = {
+        register: async (payload, options) => await this.request("POST", "/devices", {
+            ...options,
+            body: payload,
+            canRetry: true,
+            idempotencyKey: options?.idempotencyKey,
+        }).then((res) => res.body),
+        update: async (deviceId, payload, options) => await this.request("PATCH", `/devices/${deviceId}`, {
+            ...options,
+            body: payload,
+            canRetry: Boolean(options?.idempotencyKey),
+            idempotencyKey: options?.idempotencyKey,
+        }).then((res) => res.body),
+        setStatus: async (deviceId, payload, options) => await this.request("PATCH", `/devices/${deviceId}/status`, {
+            ...options,
+            body: payload,
+            canRetry: Boolean(options?.idempotencyKey),
+            idempotencyKey: options?.idempotencyKey,
+        }).then((res) => res.body),
+    };
+    anchors = {
+        create: async (payload, options) => await this.request("POST", "/anchors", {
+            ...options,
+            body: payload,
+            canRetry: true,
+            idempotencyKey: options?.idempotencyKey,
+        }).then((res) => res.body),
+    };
+    auditPacks = {
+        create: async (payload, options) => await this.request("POST", "/audit-packs", {
+            ...options,
+            body: payload,
+            canRetry: true,
+            idempotencyKey: options?.idempotencyKey,
+        }).then((res) => res.body),
+        downloadPdf: async (pdfUri) => {
+            const response = await fetch(pdfUri);
+            if (!response.ok) {
+                throw new ApiError(`Failed to download PDF: ${response.status}`, response.status);
+            }
+            return response.arrayBuffer();
+        },
+        downloadJson: async (jsonUri) => {
+            const response = await fetch(jsonUri);
+            if (!response.ok) {
+                throw new ApiError(`Failed to download JSON: ${response.status}`, response.status);
+            }
+            return response.text();
+        },
+    };
+    holograms = {
+        issue: async (payload, options) => await this.request("POST", "/holograms", {
+            ...options,
+            body: payload,
+            canRetry: true,
+            idempotencyKey: options?.idempotencyKey,
+        }).then((res) => res.body),
+        revoke: async (payload, options) => await this.request("POST", "/holograms/revoke", {
+            ...options,
+            body: payload,
+            canRetry: true,
+            idempotencyKey: options?.idempotencyKey,
+        }).then((res) => res.body),
+        verify: async (publicCode) => {
+            const response = await this.request("GET", `/verify/holograms/${publicCode}`, { canRetry: true });
+            if (response.body.status !== "ok") {
+                return null;
+            }
+            return response.body.data ?? null;
+        },
+    };
+}

package/dist/http.d.ts

@@ -0,0 +1,70 @@
+export type AuthOptions = {
+    token: string;
+} | {
+    getToken: () => Promise<string> | string;
+} | undefined;
+export type RetryOptions = {
+    enabled?: boolean;
+    maxRetries?: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+    jitterMs?: number;
+};
+export type ClientHooks = {
+    onRequest?: (context: RequestContext) => void | Promise<void>;
+    onResponse?: (context: ResponseContext) => void | Promise<void>;
+    onError?: (context: ErrorContext) => void | Promise<void>;
+};
+export type RequestContext = {
+    method: string;
+    url: string;
+    headers: Record<string, string>;
+    body?: unknown;
+    requestId: string;
+};
+export type ResponseContext = {
+    method: string;
+    url: string;
+    status: number;
+    requestId: string;
+    durationMs: number;
+};
+export type ErrorContext = {
+    method: string;
+    url: string;
+    status?: number;
+    requestId: string;
+    durationMs: number;
+    error: Error;
+};
+export declare class ApiError extends Error {
+    status?: number;
+    body?: unknown;
+    requestId?: string;
+    constructor(message: string, status?: number, body?: unknown, requestId?: string);
+}
+export type RequestOptions = {
+    headers?: Record<string, string>;
+    body?: unknown;
+    query?: Record<string, string | number | boolean | undefined | null>;
+    timeoutMs?: number;
+    idempotencyKey?: string;
+    allowInsecure?: boolean;
+    retry?: RetryOptions;
+    auth?: AuthOptions;
+    onAuthError?: (error: ApiError) => void | Promise<void>;
+    requestId?: string;
+    sdkHeaders?: Record<string, string>;
+    hooks?: ClientHooks;
+    signingHook?: (context: RequestContext) => Promise<Record<string, string> | void> | Record<string, string> | void;
+    canRetry?: boolean;
+};
+export declare const request: <T>(baseUrl: string, path: string, method: string, options: RequestOptions) => Promise<{
+    body: T;
+    requestId: string;
+}>;
+export declare const requestRaw: (baseUrl: string, path: string, method: string, options: RequestOptions) => Promise<{
+    body: unknown;
+    requestId: string;
+    headers: Headers;
+}>;