@defarm/sdk 0.1.0

package/README.md

@@ -0,0 +1,34 @@
+# @defarm/sdk
+
+SDK TypeScript para integração com a API da DeFarm via gateway.
+
+## Instalação
+
+```bash
+npm install @defarm/sdk
+```
+
+## Exemplo
+
+```ts
+import { DefarmSdk } from "@defarm/sdk";
+
+const sdk = new DefarmSdk({ gatewayBaseUrl: "https://gateway.defarm.net" });
+const auth = await sdk.auth.login("email", "senha");
+sdk.setAccessToken(auth.access_token);
+
+const circuits = await sdk.circuits.list();
+console.log(circuits);
+```
+
+## Testes
+
+```bash
+npm test
+```
+
+## Publicação no npm
+
+```bash
+npm publish --access public
+```

package/dist/client.d.ts

@@ -0,0 +1,8 @@
+import { HttpMethod, SdkConfig } from "./types.js";
+export declare class DefarmHttpClient {
+    private readonly config;
+    private accessToken?;
+    constructor(config: SdkConfig);
+    setAccessToken(token?: string): void;
+    request<T>(method: HttpMethod, path: string, body?: unknown): Promise<T>;
+}

package/dist/client.js

@@ -0,0 +1,48 @@
+import { request as undiciRequest } from "undici";
+import { DefarmApiError } from "./types.js";
+export class DefarmHttpClient {
+    config;
+    accessToken;
+    constructor(config) {
+        this.config = {
+            timeoutMs: 20000,
+            ...config,
+        };
+    }
+    setAccessToken(token) {
+        this.accessToken = token;
+    }
+    async request(method, path, body) {
+        const url = `${this.config.gatewayBaseUrl.replace(/\/$/, "")}${path}`;
+        const headers = {
+            "content-type": "application/json",
+        };
+        if (this.accessToken) {
+            headers.authorization = `Bearer ${this.accessToken}`;
+        }
+        const response = await undiciRequest(url, {
+            method,
+            headers,
+            body: body == null ? undefined : JSON.stringify(body),
+            headersTimeout: this.config.timeoutMs,
+            bodyTimeout: this.config.timeoutMs,
+        });
+        const text = await response.body.text();
+        const parsed = text ? safeJsonParse(text) : null;
+        if (response.statusCode < 200 || response.statusCode >= 300) {
+            const message = parsed?.message ||
+                parsed?.error ||
+                `HTTP ${response.statusCode} on ${path}`;
+            throw new DefarmApiError(message, response.statusCode, parsed);
+        }
+        return parsed ?? {};
+    }
+}
+function safeJsonParse(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return { raw: text };
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+import { DefarmHttpClient } from "./client.js";
+import { AuthApi, CircuitsApi, EventsApi, ItemsApi, WorkspaceApi } from "./modules.js";
+import { SdkConfig } from "./types.js";
+export * from "./types.js";
+export declare class DefarmSdk {
+    readonly auth: AuthApi;
+    readonly workspace: WorkspaceApi;
+    readonly circuits: CircuitsApi;
+    readonly items: ItemsApi;
+    readonly events: EventsApi;
+    readonly http: DefarmHttpClient;
+    constructor(config: SdkConfig);
+    setAccessToken(token?: string): void;
+}

package/dist/index.js

@@ -0,0 +1,22 @@
+import { DefarmHttpClient } from "./client.js";
+import { AuthApi, CircuitsApi, EventsApi, ItemsApi, WorkspaceApi } from "./modules.js";
+export * from "./types.js";
+export class DefarmSdk {
+    auth;
+    workspace;
+    circuits;
+    items;
+    events;
+    http;
+    constructor(config) {
+        this.http = new DefarmHttpClient(config);
+        this.auth = new AuthApi(this.http);
+        this.workspace = new WorkspaceApi(this.http);
+        this.circuits = new CircuitsApi(this.http);
+        this.items = new ItemsApi(this.http);
+        this.events = new EventsApi(this.http);
+    }
+    setAccessToken(token) {
+        this.http.setAccessToken(token);
+    }
+}

package/dist/modules.d.ts

@@ -0,0 +1,45 @@
+import { DefarmHttpClient } from "./client.js";
+import { AuthResponse, Circuit, Event, Item } from "./types.js";
+export declare class AuthApi {
+    private readonly http;
+    constructor(http: DefarmHttpClient);
+    login(email: string, password: string): Promise<AuthResponse>;
+    refresh(refreshToken: string): Promise<AuthResponse>;
+    whoami(): Promise<AuthResponse["user"]>;
+    logout(refreshToken?: string): Promise<{
+        message?: string;
+    }>;
+}
+export declare class WorkspaceApi {
+    private readonly http;
+    constructor(http: DefarmHttpClient);
+    list(): Promise<{
+        workspaces: unknown[];
+        count: number;
+    }>;
+    status(): Promise<import("./types.js").AuthUser>;
+}
+export declare class CircuitsApi {
+    private readonly http;
+    constructor(http: DefarmHttpClient);
+    list(): Promise<Circuit[]>;
+    show(id: string): Promise<Circuit>;
+    members(id: string): Promise<unknown>;
+    join(id: string, message?: string): Promise<unknown>;
+}
+export declare class ItemsApi {
+    private readonly http;
+    constructor(http: DefarmHttpClient);
+    list(circuitId?: string): Promise<Item[]>;
+    show(id: string): Promise<unknown>;
+    create(payload: Record<string, unknown>): Promise<unknown>;
+    update(id: string, payload: Record<string, unknown>): Promise<unknown>;
+}
+export declare class EventsApi {
+    private readonly http;
+    constructor(http: DefarmHttpClient);
+    list(circuitId?: string): Promise<Event[]>;
+    show(id: string): Promise<Event>;
+    add(payload: Record<string, unknown>): Promise<unknown>;
+    update(id: string, payload: Record<string, unknown>): Promise<unknown>;
+}

package/dist/modules.js

@@ -0,0 +1,91 @@
+export class AuthApi {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    async login(email, password) {
+        return this.http.request("POST", "/auth/login", { email, password });
+    }
+    async refresh(refreshToken) {
+        return this.http.request("POST", "/auth/refresh", { refresh_token: refreshToken });
+    }
+    async whoami() {
+        return this.http.request("GET", "/auth/me");
+    }
+    async logout(refreshToken) {
+        return this.http.request("POST", "/auth/logout", {
+            refresh_token: refreshToken,
+        });
+    }
+}
+export class WorkspaceApi {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    async list() {
+        return this.http.request("GET", "/auth/workspaces");
+    }
+    async status() {
+        return this.http.request("GET", "/auth/me");
+    }
+}
+export class CircuitsApi {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    async list() {
+        const res = await this.http.request("GET", "/api/circuits");
+        return Array.isArray(res) ? res : res.circuits || [];
+    }
+    async show(id) {
+        return this.http.request("GET", `/api/circuits/${id}`);
+    }
+    async members(id) {
+        return this.http.request("GET", `/api/circuits/${id}/members`);
+    }
+    async join(id, message) {
+        return this.http.request("POST", `/api/circuits/${id}/join-requests`, message ? { message } : {});
+    }
+}
+export class ItemsApi {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    async list(circuitId) {
+        const qs = circuitId ? `?circuit_id=${encodeURIComponent(circuitId)}` : "";
+        const res = await this.http.request("GET", `/api/items${qs}`);
+        return Array.isArray(res) ? res : res.items || [];
+    }
+    async show(id) {
+        return this.http.request("GET", `/api/items/${id}`);
+    }
+    async create(payload) {
+        return this.http.request("POST", "/api/items", payload);
+    }
+    async update(id, payload) {
+        return this.http.request("PUT", `/api/items/${id}`, payload);
+    }
+}
+export class EventsApi {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    async list(circuitId) {
+        const qs = circuitId ? `?circuit_id=${encodeURIComponent(circuitId)}` : "";
+        const res = await this.http.request("GET", `/api/events${qs}`);
+        return Array.isArray(res) ? res : res.events || [];
+    }
+    async show(id) {
+        return this.http.request("GET", `/api/events/${id}`);
+    }
+    async add(payload) {
+        return this.http.request("POST", "/api/events", payload);
+    }
+    async update(id, payload) {
+        return this.http.request("PUT", `/api/events/${id}/status`, payload);
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,57 @@
+export type WorkspaceType = "partner" | "producer" | "processor" | "certifier";
+export type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+export interface SdkConfig {
+    gatewayBaseUrl: string;
+    timeoutMs?: number;
+}
+export interface AuthTokens {
+    access_token: string;
+    refresh_token?: string;
+    token_type?: string;
+    expires_in?: number;
+}
+export interface AuthUser {
+    id: string;
+    email: string;
+    full_name?: string;
+    workspace: {
+        id: string;
+        name: string;
+        slug: string;
+        workspace_type: WorkspaceType;
+        role: string;
+    };
+}
+export interface AuthResponse extends AuthTokens {
+    user: AuthUser;
+}
+export interface Circuit {
+    id: string;
+    name: string;
+    description?: string;
+    visibility?: string;
+    circuit_type?: string;
+    status?: string;
+}
+export interface Item {
+    id: string;
+    dfid: string;
+    value_chain: string;
+    country: string;
+    year: number;
+    status: string;
+    metadata?: Record<string, unknown>;
+}
+export interface Event {
+    id: string;
+    event_type: string;
+    status?: string;
+    item_id?: string;
+    circuit_id?: string;
+    payload?: Record<string, unknown>;
+}
+export declare class DefarmApiError extends Error {
+    status: number;
+    details?: unknown;
+    constructor(message: string, status: number, details?: unknown);
+}

package/dist/types.js

@@ -0,0 +1,9 @@
+export class DefarmApiError extends Error {
+    status;
+    details;
+    constructor(message, status, details) {
+        super(message);
+        this.status = status;
+        this.details = details;
+    }
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@defarm/sdk",
+  "version": "0.1.0",
+  "description": "DeFarm SDK for CLI and partner integrations",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/defarm-repo/engines.git",
+    "directory": "tooling/defarm-sdk"
+  },
+  "homepage": "https://defarm.net",
+  "bugs": {
+    "url": "https://github.com/defarm-repo/engines/issues"
+  },
+  "keywords": [
+    "defarm",
+    "traceability",
+    "agri",
+    "sdk",
+    "stellar"
+  ],
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": ["dist"],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "test": "npm run build && node --test test/*.test.mjs",
+    "prepublishOnly": "npm run check && npm run test"
+  },
+  "dependencies": {
+    "undici": "^6.19.8"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.3"
+  }
+}