@renderinc/sdk 0.2.1 → 0.3.0

package/src/workflows/types.test.ts

@@ -1,52 +0,0 @@
-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

@@ -1,89 +0,0 @@
-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

@@ -1,139 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

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

package/tsconfig.json

@@ -1,23 +0,0 @@
-{
-  "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

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