deplugger
> the integration console
Hassle-free, low-code workflows for any API. Plug in a cartridge, test it, compile it, run it. The runtime you can hold.
Any API, in moments.
The cartridge metaphor is literal โ each plug-in is a removable module of ops. Same chassis, different cartridges. Compose them into workflows. Run them anywhere.
Three quiet contrasts with the rest of the field. Same scope, different posture.
Code-first, but you don't have to write it all.
Effect-native runtime, schema-driven payloads, typed errors all the way down. Drop into TypeScript when you need to. Stay in JSON when you don't.
No Python lock-in. No DAG religion.
Workflows are data, not Python. Authoring is JSON. Runtime is Effect. Compile target is your choice โ ephemeral or durable, same DSL.
Built for integrations, not job orchestration.
Plug-in providers, not opinionated scheduling. Test your ops in isolation. Compose them. Replay them. Inspect them. Then ship.
The same console.
Three cartridges. Live.
> pick one. press run. the runtime is real; the data is canned.
Effect-native. Typed all the way down. Author ops in TypeScript, run them anywhere โ schema-decoded payloads, tagged errors, replayable activities.
An op is a typed function with metadata.
// define an op
export const quote = makeOp({
name: "shipping.quote",
kind: "effectful",
input: PackageSchema,
output: QuoteSchema,
exec: (pkg) =>
Effect.gen(function* () {
const carriers = yield* CarrierService;
return yield* carriers.quote(pkg);
}),
});Workflows are data โ JSON, not code.
// compose ops into a workflow
export const dispatch = workflow({
mode: "durable",
body: [
{ i: { $pkg: pkg }, op: "shipping.quote", o: "$quote" },
{ match: { $: "$quote" },
branches: [
{ case: { gt: 100 }, body: [
{ i: { $q: "$quote" }, op: "alert.slack", o: "$_" }
]}
]
},
]
});Layers stub everything. Tests stay fast.
// test an op without a runtime
const result = yield* Effect.runPromise(
quote.exec(testPkg).pipe(
Effect.provide(testCarrierLayer)
)
);
expect(result.priceMxn).toBe(89);Same DSL, two compile targets.
// ephemeral โ plain Effect.gen
runEphemeral(dispatch, pkg)
// durable โ Workflow + Activity, replayable
runDurable(dispatch, pkg, {
engine: ClusterWorkflowEngine.layer
})Every workflow run is observable through the same chassis vocabulary you author with. LCDs narrate. LEDs flag state. Replay is one click.
See every step, in order, as it happens.
Failed runs replay deterministically.
Activities are once-only on replay. Pure ops re-run for free. Cluster-grade durability, no cluster-grade ceremony.