@apifuse/provider-sdk 2.0.0-beta.1 → 2.1.0-beta.0

package/src/cli/templates/provider/Dockerfile.tpl

@@ -0,0 +1,7 @@
+FROM oven/bun:1.2-alpine
+WORKDIR /provider
+COPY package.json bun.lockb* ./
+RUN bun install --frozen-lockfile
+COPY . .
+EXPOSE 3000
+CMD ["bun", "run", "start"]

package/src/cli/templates/provider/README.md.tpl

@@ -0,0 +1,28 @@
+# {{DISPLAY_NAME}}
+
+Generated with `apifuse create`.
+
+## Commands
+
+```bash
+bun run dev
+bun run check
+bun run test
+```
+
+## Provider server contract
+
+- Dev default: `3900`
+- Start/Docker/container contract: `3000`
+- `GET /health`
+- `POST /v1/{operation}`
+- `POST /auth/start`
+- `POST /auth/continue`
+- `POST /auth/poll`
+- `POST /auth/disconnect`
+
+## Next steps
+
+1. Replace the sample `ping` operation with real upstream logic.
+2. Record a real fixture with `bun run record:sample` or a provider-specific equivalent.
+3. Extend tests and operation metadata until the provider is bounty-ready.

package/src/cli/templates/provider/dev.ts.tpl

@@ -0,0 +1,5 @@
+import { startDevServer } from "@apifuse/provider-sdk";
+
+import provider from "./index";
+
+startDevServer(provider, { port: Number(process.env.PORT) || 3900 });

package/src/cli/templates/provider/index.test.ts.tpl

@@ -0,0 +1,13 @@
+import { describe, expect, it } from "bun:test";
+import { runStandardTests } from "@apifuse/provider-sdk/testing";
+
+import provider from "../index";
+
+runStandardTests(provider);
+
+describe("{{PROVIDER_ID}}", () => {
+  it("exposes provider metadata from defineProvider", () => {
+    expect(provider.id).toBe("{{PROVIDER_ID}}");
+    expect(provider.reviewed).toBe("community");
+  });
+});

package/src/cli/templates/provider/index.ts.tpl

@@ -0,0 +1,54 @@
+import { defineProvider, z } from "@apifuse/provider-sdk";
+
+const InputSchema = z
+  .object({
+    value: z
+      .string()
+      .default("hello")
+      .describe("Sample input value used to verify the generated provider scaffold is wired correctly."),
+  })
+  .describe("Input payload for the generated ping operation.");
+
+const OutputSchema = z
+  .object({
+    ok: z
+      .boolean()
+      .describe("Whether the generated provider handled the sample request successfully."),
+    message: z
+      .string()
+      .describe("Human-readable confirmation that the generated provider round-tripped the sample payload."),
+  })
+  .describe("Output payload returned by the generated ping operation.");
+
+export default defineProvider({
+  id: "{{PROVIDER_ID}}",
+  version: "1.0.0",
+  runtime: "{{RUNTIME}}"{{BROWSER_BLOCK}},
+  allowedHosts: ["api.example.com"],
+  reviewed: "community",
+  {{SECRETS_BLOCK}}{{CREDENTIAL_BLOCK}}auth: {{AUTH_BLOCK}},
+  meta: {
+    displayName: "{{DISPLAY_NAME}}",
+    description: "{{DISPLAY_NAME}} provider starter for ApiFuse community contributions.",
+    category: "{{CATEGORY}}",
+    tags: ["{{PROVIDER_ID}}", "starter", "community"],
+  },
+  operations: {
+    ping: {
+      description:
+        "Confirms the generated provider wiring is operational by echoing a small sample payload through the ApiFuse runtime contract. Use when validating local development, baseline checks, or first-pass bounty scaffolds. Do NOT use for production data retrieval or upstream-specific workflows because this starter operation exists only to prove the generated project compiles, serves, and round-trips input/output correctly. Returns a success flag plus a message containing the supplied value.",
+      input: InputSchema,
+      output: OutputSchema,
+      handler: async (_ctx, input) => {
+        return {
+          ok: true,
+          message: "{{DISPLAY_NAME}} received: " + input.value,
+        };
+      },
+      fixtures: {
+        request: { value: "hello" },
+        response: { ok: true, message: "{{DISPLAY_NAME}} received: hello" },
+      },
+    },
+  },
+});

package/src/cli/templates/provider/start.ts.tpl

@@ -0,0 +1,5 @@
+import { serve } from "@apifuse/provider-sdk";
+
+import provider from "./index";
+
+await serve(provider, { port: Number(process.env.PORT) || 3000 });

package/src/composite.ts

@@ -0,0 +1,43 @@
+import type { infer as ZodInfer, ZodType } from "zod";
+
+export interface ClarifyResponse {
+	_type: "clarify";
+	question: string;
+	missing: Array<{ name: string; description: string }>;
+}
+
+export interface CompositeContext {
+	chain: {
+		call: <T>(operationKey: string, params: unknown) => Promise<T>;
+	};
+	clarify: (opts: {
+		question: string;
+		missing: Array<{ name: string; description: string }>;
+	}) => ClarifyResponse;
+	setSlot: (name: string, value: unknown) => void;
+}
+
+export interface CompositeOperationDefinition<
+	TInput extends ZodType = ZodType,
+	TOutput extends ZodType = ZodType,
+> {
+	id: string;
+	description: string;
+	input: TInput;
+	output: TOutput;
+	tags?: string[];
+	chainsWith?: string[];
+	steps: (
+		ctx: CompositeContext,
+		input: ZodInfer<TInput>,
+	) => Promise<ZodInfer<TOutput> | ClarifyResponse>;
+}
+
+export function defineCompositeOperation<
+	TInput extends ZodType,
+	TOutput extends ZodType,
+>(
+	config: CompositeOperationDefinition<TInput, TOutput>,
+): CompositeOperationDefinition<TInput, TOutput> {
+	return config;
+}