@renderinc/sdk 0.1.0 → 0.2.1

package/src/workflows/types.test.ts

@@ -0,0 +1,52 @@
+import type { TaskContext, TaskFunction, TaskResult } from "./types.js";
+
+describe("TaskFunction type", () => {
+  it("accepts typed args and returns typed result", () => {
+    expectTypeOf<TaskFunction<[string, number], boolean>>().toExtend<
+      (a: string, b: number) => boolean | Promise<boolean>
+    >();
+  });
+
+  it("defaults to any[] args and any result", () => {
+    expectTypeOf<TaskFunction>().toExtend<(...args: any[]) => any>();
+  });
+
+  it("allows async return type", () => {
+    const asyncFn: TaskFunction<[string], number> = async (s) => s.length;
+    expectTypeOf(asyncFn).returns.toExtend<number | Promise<number>>();
+  });
+
+  it("allows sync return type", () => {
+    const syncFn: TaskFunction<[string], number> = (s) => s.length;
+    expectTypeOf(syncFn).returns.toExtend<number | Promise<number>>();
+  });
+});
+
+describe("TaskResult type", () => {
+  it("get() returns Promise<T>", () => {
+    expectTypeOf<TaskResult<string>>().toHaveProperty("get");
+    expectTypeOf<TaskResult<string>["get"]>().returns.toEqualTypeOf<Promise<string>>();
+  });
+
+  it("preserves generic parameter", () => {
+    type NumberResult = TaskResult<number>;
+    type StringResult = TaskResult<string>;
+    expectTypeOf<NumberResult["get"]>().returns.toEqualTypeOf<Promise<number>>();
+    expectTypeOf<StringResult["get"]>().returns.toEqualTypeOf<Promise<string>>();
+  });
+});
+
+describe("TaskContext type", () => {
+  it("has executeTask method", () => {
+    expectTypeOf<TaskContext>().toHaveProperty("executeTask");
+  });
+
+  it("executeTask is callable", () => {
+    type ExecuteTask = TaskContext["executeTask"];
+    expectTypeOf<ExecuteTask>().toBeCallableWith(
+      {} as TaskFunction<[string], number>,
+      "taskName",
+      "arg",
+    );
+  });
+});

package/src/workflows/types.ts

@@ -0,0 +1,89 @@
+import type { components } from "./schema.js";
+
+/**
+ * Task function signature
+ */
+export type TaskFunction<TArgs extends any[] = any[], TResult = any> = (
+  ...args: TArgs
+) => TResult | Promise<TResult>;
+
+export type TaskOptions = components["schemas"]["TaskOptions"];
+
+/**
+ * Task metadata
+ */
+export interface TaskMetadata {
+  name: string;
+  func: TaskFunction;
+  options?: TaskOptions;
+}
+
+/**
+ * Task context for executing subtasks
+ */
+export interface TaskContext {
+  executeTask<TArgs extends any[], TResult>(
+    task: TaskFunction<TArgs, TResult>,
+    taskName: string,
+    ...args: TArgs
+  ): TaskResult<TResult>;
+}
+
+/**
+ * Result of a task execution
+ */
+export interface TaskResult<T> {
+  get(): Promise<T>;
+}
+
+/**
+ * Task input from the workflow system
+ */
+export interface TaskInput {
+  task_name: string;
+  input: any[];
+}
+
+/**
+ * Task callback request/response types
+ */
+
+export type CallbackRequest = components["schemas"]["CallbackRequest"];
+
+export type GetInputResponse = components["schemas"]["InputResponse"];
+
+export type RunSubtaskRequest = components["schemas"]["RunSubtaskRequest"];
+
+export type RunSubtaskResponse = components["schemas"]["RunSubtaskResponse"];
+
+export type GetSubtaskResultRequest = components["schemas"]["SubtaskResultRequest"];
+
+export type GetSubtaskResultResponse = components["schemas"]["SubtaskResultResponse"];
+
+export type RegisterTasksRequest = components["schemas"]["Tasks"];
+
+/**
+ * Retry configuration for task execution
+ */
+export interface Retry {
+  maxRetries: number;
+  waitDurationMs: number;
+  backoffScaling?: number; // default 1.5
+}
+
+/**
+ * Task execution options
+ */
+export interface RegisterTaskOptions {
+  retry?: Retry;
+  timeoutSeconds?: number;
+  /**
+   * Resource plan for task execution.
+   * Common plans include:
+   * - "starter": 0.5 CPU, 512MB memory
+   * - "standard": 1 CPU, 2GB memory (default)
+   * - "pro": 2 CPU, 4GB memory
+   */
+  plan?: string;
+  name: string;
+}

package/src/workflows/uds.ts

@@ -0,0 +1,139 @@
+import http from "node:http";
+import { getUserAgent } from "../version.js";
+
+import type {
+  CallbackRequest,
+  GetInputResponse,
+  GetSubtaskResultRequest,
+  GetSubtaskResultResponse,
+  RegisterTasksRequest,
+  RunSubtaskRequest,
+  RunSubtaskResponse,
+  TaskMetadata,
+} from "./types.js";
+
+/**
+ * Unix Domain Socket client for communicating with the workflow system
+ */
+export class UDSClient {
+  constructor(private readonly socketPath: string) {}
+
+  /**
+   * Get task input and name
+   */
+  async getInput(): Promise<GetInputResponse> {
+    return this.request<GetInputResponse>("/input", "GET");
+  }
+
+  private buildCallbackBody(results?: any, error?: string): CallbackRequest {
+    if (results !== undefined) {
+      const resultsArray = [results];
+      const output = Buffer.from(JSON.stringify(resultsArray)).toString("base64");
+      return {
+        complete: {
+          output,
+        },
+      };
+    }
+
+    if (error === undefined) {
+      throw new Error("Either results or error must be provided");
+    }
+
+    return {
+      error: {
+        details: error,
+      },
+    };
+  }
+
+  /**
+   * Send task result or error
+   */
+  async sendCallback(results?: any, error?: string): Promise<void> {
+    await this.request<void>("/callback", "POST", this.buildCallbackBody(results, error));
+  }
+
+  /**
+   * Run a subtask
+   */
+  async runSubtask(taskName: string, input: any[]): Promise<string> {
+    const inputBase64 = Buffer.from(JSON.stringify(input)).toString("base64");
+    const body: RunSubtaskRequest = {
+      task_name: taskName,
+      input: inputBase64,
+    };
+    const response = await this.request<RunSubtaskResponse>("/run-subtask", "POST", body);
+    return response.task_run_id;
+  }
+
+  /**
+   * Get subtask result
+   */
+  async getSubtaskResult(subtaskId: string): Promise<GetSubtaskResultResponse> {
+    const body: GetSubtaskResultRequest = {
+      task_run_id: subtaskId,
+    };
+    return this.request<GetSubtaskResultResponse>("/get-subtask-result", "POST", body);
+  }
+
+  /**
+   * Register tasks with the workflow system
+   */
+  async registerTasks(tasks: TaskMetadata[]): Promise<void> {
+    const body: RegisterTasksRequest = {
+      tasks: tasks.map((task) => ({
+        name: task.name,
+        options: task.options,
+      })),
+    };
+    await this.request<void>("/register-tasks", "POST", body);
+  }
+
+  /**
+   * Make a request to the Unix socket
+   */
+  private async request<T>(path: string, method: string, body?: any): Promise<T> {
+    return new Promise((resolve, reject) => {
+      const req = http.request(
+        {
+          socketPath: this.socketPath,
+          path: path,
+          method: method,
+          headers: {
+            "Content-Length": body ? JSON.stringify(body).length : 0,
+            "Content-Type": "application/json",
+            "User-Agent": getUserAgent(),
+          },
+        },
+        async (res) => {
+          const chunks: Buffer[] = [];
+          for await (const chunk of res) chunks.push(chunk);
+          const responseBody = Buffer.concat(chunks).toString();
+
+          if (res.statusCode && res.statusCode >= 400) {
+            reject(new Error(`HTTP ${res.statusCode}: ${responseBody}`));
+            return;
+          }
+
+          if (responseBody.length === 0) {
+            resolve(undefined as T);
+            return;
+          }
+
+          try {
+            resolve(JSON.parse(responseBody));
+          } catch (error) {
+            reject(error);
+          }
+        },
+      );
+      req.on("error", (error) => {
+        reject(error);
+      });
+
+      // Write the body to the request
+      req.end(body ? JSON.stringify(body) : "");
+    });
+  }
+}

package/test-types.ts

@@ -0,0 +1,14 @@
+import { Render } from "./src";
+
+export async function test() {
+  const render = new Render({
+    baseUrl: "https://api.localhost.render.com:8443",
+    token: "test",
+  });
+
+  const taskRun = await render.workflows.runTask("workflow-sdk/greet", ["Ruben"]);
+
+  // This should show the type
+  const taskRunType = typeof taskRun;
+  console.log(taskRunType);
+}

package/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+}

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "NodeNext",
+    "lib": ["ES2020"],
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "removeComments": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "moduleResolution": "NodeNext",
+    "resolveJsonModule": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "types": ["node", "vitest/globals"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    include: ["src/**/*.test.ts"],
+    globals: true,
+  },
+});

package/dist/workflows/client/errors.d.ts

@@ -1,25 +0,0 @@
-export declare class RenderError extends Error {
-    constructor(message: string);
-}
-export declare class TaskRunError extends RenderError {
-    taskRunId?: string | undefined;
-    taskError?: string | undefined;
-    constructor(message: string, taskRunId?: string | undefined, taskError?: string | undefined);
-}
-export declare class ClientError extends RenderError {
-    statusCode: number;
-    response?: any | undefined;
-    constructor(message: string, statusCode: number, response?: any | undefined);
-}
-export declare class ServerError extends RenderError {
-    statusCode: number;
-    response?: any | undefined;
-    constructor(message: string, statusCode: number, response?: any | undefined);
-}
-export declare class TimeoutError extends RenderError {
-    constructor(message: string);
-}
-export declare class AbortError extends Error {
-    constructor();
-}
-//# sourceMappingURL=errors.d.ts.map

package/dist/workflows/client/errors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/workflows/client/errors.ts"],"names":[],"mappings":"AAGA,qBAAa,WAAY,SAAQ,KAAK;gBACxB,OAAO,EAAE,MAAM;CAK5B;AAKD,qBAAa,YAAa,SAAQ,WAAW;IAGlC,SAAS,CAAC,EAAE,MAAM;IAClB,SAAS,CAAC,EAAE,MAAM;gBAFzB,OAAO,EAAE,MAAM,EACR,SAAS,CAAC,EAAE,MAAM,YAAA,EAClB,SAAS,CAAC,EAAE,MAAM,YAAA;CAM5B;AAKD,qBAAa,WAAY,SAAQ,WAAW;IAGjC,UAAU,EAAE,MAAM;IAClB,QAAQ,CAAC,EAAE,GAAG;gBAFrB,OAAO,EAAE,MAAM,EACR,UAAU,EAAE,MAAM,EAClB,QAAQ,CAAC,EAAE,GAAG,YAAA;CAMxB;AAKD,qBAAa,WAAY,SAAQ,WAAW;IAGjC,UAAU,EAAE,MAAM;IAClB,QAAQ,CAAC,EAAE,GAAG;gBAFrB,OAAO,EAAE,MAAM,EACR,UAAU,EAAE,MAAM,EAClB,QAAQ,CAAC,EAAE,GAAG,YAAA;CAMxB;AAKD,qBAAa,YAAa,SAAQ,WAAW;gBAC/B,OAAO,EAAE,MAAM;CAK5B;AAED,qBAAa,UAAW,SAAQ,KAAK;;CAKpC"}

package/dist/workflows/client/errors.js

@@ -1,56 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbortError = exports.TimeoutError = exports.ServerError = exports.ClientError = exports.TaskRunError = exports.RenderError = void 0;
-class RenderError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'RenderError';
-        Object.setPrototypeOf(this, RenderError.prototype);
-    }
-}
-exports.RenderError = RenderError;
-class TaskRunError extends RenderError {
-    constructor(message, taskRunId, taskError) {
-        super(message);
-        this.taskRunId = taskRunId;
-        this.taskError = taskError;
-        this.name = 'TaskRunError';
-        Object.setPrototypeOf(this, TaskRunError.prototype);
-    }
-}
-exports.TaskRunError = TaskRunError;
-class ClientError extends RenderError {
-    constructor(message, statusCode, response) {
-        super(message);
-        this.statusCode = statusCode;
-        this.response = response;
-        this.name = 'ClientError';
-        Object.setPrototypeOf(this, ClientError.prototype);
-    }
-}
-exports.ClientError = ClientError;
-class ServerError extends RenderError {
-    constructor(message, statusCode, response) {
-        super(message);
-        this.statusCode = statusCode;
-        this.response = response;
-        this.name = 'ServerError';
-        Object.setPrototypeOf(this, ServerError.prototype);
-    }
-}
-exports.ServerError = ServerError;
-class TimeoutError extends RenderError {
-    constructor(message) {
-        super(message);
-        this.name = 'TimeoutError';
-        Object.setPrototypeOf(this, TimeoutError.prototype);
-    }
-}
-exports.TimeoutError = TimeoutError;
-class AbortError extends Error {
-    constructor() {
-        super('The operation was aborted.');
-        this.name = 'AbortError';
-    }
-}
-exports.AbortError = AbortError;