@clovnet/plugin-cli 0.2.2

package/templates/provider-skeleton/src/adapter.ts

@@ -0,0 +1,164 @@
+import type {
+  BalanceResult,
+  BetResult,
+  CloseRoundInput,
+  CreateSessionInput,
+  CreateSessionResult,
+  PlaceBetInput,
+  PluginContext,
+  ProviderAdapter,
+  ProviderContext,
+  RollbackInput,
+  RoundResult,
+  SettleBetInput,
+} from "@clovnet/plugin-sdk";
+import { FakeProviderBackend } from "./fake-backend.js";
+
+export const PROVIDER_KEY = "__PLUGIN_KEY__";
+
+/** Wallet command names, referenced by string — an external plugin depends
+ * only on the SDK. The manifest allowlists exactly these. */
+export const WALLET_PLACE_BET = "wallet.bet.place";
+export const WALLET_SETTLE_BET = "wallet.bet.settle";
+export const WALLET_ROLLBACK_BET = "wallet.bet.rollback";
+
+/** Shape of the wallet MovementResult fields the adapter reads. */
+interface MovementLike {
+  transactionId: string;
+  legs: Array<{ balanceAfter: string }>;
+}
+
+/**
+ * The provider adapter NORMALIZES provider API shapes into internal wallet
+ * commands — it never mutates wallets directly: `placeBet` →
+ * `wallet.bet.place`, `settleBet` → `wallet.bet.settle`, `rollback` →
+ * `wallet.bet.rollback`, all through `ctx.commands.execute`
+ * (allowlist-enforced). Provider transaction ids are the idempotency keys,
+ * so a replayed provider callback can never double-move money.
+ */
+export class ProviderSkeletonAdapter implements ProviderAdapter {
+  readonly name = PROVIDER_KEY;
+
+  private readonly sessions = new Map<string, { playerId: string; gameId: string; currency: string }>();
+  /** roundId → wallet transactionId of the bet (rollback needs the original). */
+  private readonly betTransactions = new Map<string, string>();
+  private readonly lastBalances = new Map<string, string>();
+
+  constructor(
+    private readonly ctx: PluginContext,
+    private readonly backend: FakeProviderBackend,
+  ) {}
+
+  async createSession(_pctx: ProviderContext, input: CreateSessionInput): Promise<CreateSessionResult> {
+    const { sessionId, launchUrl } = this.backend.createSession(input);
+    this.sessions.set(sessionId, {
+      playerId: input.playerId,
+      gameId: input.gameId,
+      currency: input.currency,
+    });
+    this.ctx.logger.info("__PLUGIN_KEY__.session_created", { sessionId, gameId: input.gameId });
+    return { sessionId, launchUrl };
+  }
+
+  async getBalance(_pctx: ProviderContext, playerId: string, currency: string): Promise<BalanceResult> {
+    // Plugins hold no wallet-read capability: report the balance the wallet
+    // returned on the last movement (what a real aggregator caches).
+    return { currency, balance: this.lastBalances.get(`${playerId}:${currency}`) ?? "0.0000" };
+  }
+
+  private session(sessionId: string): { playerId: string; gameId: string; currency: string } {
+    const session = this.sessions.get(sessionId);
+    if (!session) throw new Error(`unknown session '${sessionId}'`);
+    return session;
+  }
+
+  async placeBet(_pctx: ProviderContext, input: PlaceBetInput): Promise<BetResult> {
+    const session = this.session(input.sessionId);
+    const { providerTxId } = this.backend.wager({ sessionId: input.sessionId, roundId: input.roundId });
+
+    const result = await this.ctx.commands.execute<MovementLike>({
+      name: WALLET_PLACE_BET,
+      input: {
+        playerId: session.playerId,
+        amount: Number(input.amount),
+        currency: input.currency,
+        provider: PROVIDER_KEY,
+        roundId: input.roundId,
+        gameId: session.gameId,
+        externalTransactionId: providerTxId,
+        idempotencyKey: `${PROVIDER_KEY}:${providerTxId}`,
+      },
+    });
+
+    this.betTransactions.set(input.roundId, result.transactionId);
+    const balance = result.legs[0]?.balanceAfter ?? "0.0000";
+    this.lastBalances.set(`${session.playerId}:${input.currency}`, balance);
+    return { roundId: input.roundId, balance, status: "ok" };
+  }
+
+  async settleBet(_pctx: ProviderContext, input: SettleBetInput): Promise<BetResult> {
+    const session = this.session(input.sessionId);
+    const { providerTxId } = this.backend.result({ sessionId: input.sessionId, roundId: input.roundId });
+
+    const result = await this.ctx.commands.execute<MovementLike>({
+      name: WALLET_SETTLE_BET,
+      input: {
+        playerId: session.playerId,
+        amount: Number(input.payout),
+        currency: input.currency,
+        provider: PROVIDER_KEY,
+        roundId: input.roundId,
+        gameId: session.gameId,
+        externalTransactionId: providerTxId,
+        idempotencyKey: `${PROVIDER_KEY}:${providerTxId}`,
+      },
+    });
+
+    const balance =
+      result.legs[0]?.balanceAfter ?? this.lastBalances.get(`${session.playerId}:${input.currency}`) ?? "0.0000";
+    this.lastBalances.set(`${session.playerId}:${input.currency}`, balance);
+
+    await this.ctx.events.emit({
+      name: "plugin.__PLUGIN_KEY__.round_completed",
+      payload: { roundId: input.roundId, playerId: session.playerId, payout: input.payout },
+    });
+    return { roundId: input.roundId, balance, status: "ok" };
+  }
+
+  async rollback(_pctx: ProviderContext, input: RollbackInput): Promise<BetResult> {
+    const session = this.session(input.sessionId);
+    this.backend.rollback({ sessionId: input.sessionId, roundId: input.roundId });
+
+    const betTxId = this.betTransactions.get(input.roundId);
+    if (!betTxId) throw new Error(`no bet on record for round '${input.roundId}'`);
+
+    // Deterministic idempotency (`rollback:<txId>`): a duplicate rollback
+    // replays — it never reverses twice.
+    const result = await this.ctx.commands.execute<MovementLike>({
+      name: WALLET_ROLLBACK_BET,
+      input: {
+        transactionId: betTxId,
+        reason: "provider_rollback",
+        idempotencyKey: `rollback:${betTxId}`,
+      },
+    });
+
+    const balance = result.legs[0]?.balanceAfter ?? "0.0000";
+    this.lastBalances.set(`${session.playerId}:${session.currency}`, balance);
+    return { roundId: input.roundId, balance, status: "ok" };
+  }
+
+  async closeRound(_pctx: ProviderContext, input: CloseRoundInput): Promise<RoundResult> {
+    this.backend.closeRound({ sessionId: input.sessionId, roundId: input.roundId });
+    this.betTransactions.delete(input.roundId);
+    return { roundId: input.roundId, status: "closed" };
+  }
+
+  async freeSpin(): Promise<BetResult> {
+    return { roundId: "", balance: "0.0000", status: "rejected" };
+  }
+
+  async bonusWin(): Promise<BetResult> {
+    return { roundId: "", balance: "0.0000", status: "rejected" };
+  }
+}

package/templates/provider-skeleton/src/fake-backend.ts

@@ -0,0 +1,56 @@
+/**
+ * An in-memory stand-in for the real provider's API. Replace every method
+ * with real HTTP calls (`ctx.http.fetch` against `settings.baseUrl` with
+ * `secretHeaders: { authorization: "apiKey" }`) when integrating — until
+ * then the whole bet lifecycle is exercisable end-to-end offline.
+ */
+export interface FakeSession {
+  sessionId: string;
+  playerId: string;
+  gameId: string;
+  currency: string;
+}
+
+export class FakeProviderBackend {
+  private counter = 0;
+  private readonly sessions = new Map<string, FakeSession>();
+
+  constructor(private readonly opts: { baseUrl: string; operatorId: string }) {}
+
+  createSession(input: { playerId: string; gameId: string; currency: string }): {
+    sessionId: string;
+    launchUrl: string;
+  } {
+    const sessionId = `sess_${++this.counter}`;
+    this.sessions.set(sessionId, { sessionId, ...input });
+    return {
+      sessionId,
+      launchUrl: `${this.opts.baseUrl}/launch/${input.gameId}?session=${sessionId}&op=${this.opts.operatorId}`,
+    };
+  }
+
+  /** The fake mints provider transaction ids the way a real aggregator would. */
+  wager(input: { sessionId: string; roundId: string }): { providerTxId: string } {
+    this.assertSession(input.sessionId);
+    return { providerTxId: `wager_${input.roundId}` };
+  }
+
+  result(input: { sessionId: string; roundId: string }): { providerTxId: string } {
+    this.assertSession(input.sessionId);
+    return { providerTxId: `result_${input.roundId}` };
+  }
+
+  rollback(input: { sessionId: string; roundId: string }): void {
+    this.assertSession(input.sessionId);
+  }
+
+  closeRound(input: { sessionId: string; roundId: string }): void {
+    this.assertSession(input.sessionId);
+  }
+
+  private assertSession(sessionId: string): FakeSession {
+    const session = this.sessions.get(sessionId);
+    if (!session) throw new Error(`unknown provider session '${sessionId}'`);
+    return session;
+  }
+}

package/templates/provider-skeleton/src/handlers/hooks.ts

@@ -0,0 +1,30 @@
+import type { PluginContext } from "@clovnet/plugin-sdk";
+
+/**
+ * Lifecycle hooks. `onEnable` demands the provider credentials: enabling a
+ * provider without its secrets is a misconfiguration the platform surfaces
+ * as `state=errored` — better at enable time than on the first real bet.
+ */
+export async function onInstall(ctx: PluginContext): Promise<void> {
+  ctx.logger.info("__PLUGIN_KEY__.installed");
+}
+
+export async function onEnable(ctx: PluginContext): Promise<void> {
+  const apiKey = await ctx.secrets.get("apiKey");
+  if (!apiKey) {
+    throw new Error("__PLUGIN_KEY__ requires the 'apiKey' secret — save settings before enabling");
+  }
+  ctx.logger.info("__PLUGIN_KEY__.enabled");
+}
+
+export async function onConfigure(ctx: PluginContext): Promise<void> {
+  ctx.logger.info("__PLUGIN_KEY__.configured");
+}
+
+export async function onDisable(ctx: PluginContext): Promise<void> {
+  ctx.logger.info("__PLUGIN_KEY__.disabled");
+}
+
+export async function onUninstall(ctx: PluginContext): Promise<void> {
+  ctx.logger.info("__PLUGIN_KEY__.uninstalled");
+}

package/templates/provider-skeleton/src/handlers/jobs.ts

@@ -0,0 +1,16 @@
+import type { PluginContext } from "@clovnet/plugin-sdk";
+
+/**
+ * Nightly reconciliation placeholder: a real provider integration re-fetches
+ * open rounds / the game catalog here (via `ctx.http.fetch` against the
+ * allowlisted provider host). Dry-run: `cwe-plugin jobs run reconcile`.
+ */
+export async function reconcile(ctx: PluginContext): Promise<void> {
+  const { baseUrl } = ctx.settings.get<{ baseUrl?: string }>();
+  ctx.logger.info("__PLUGIN_KEY__.reconcile_started", { baseUrl });
+  // Example allowlisted outbound call with host-side secret injection:
+  //   const res = await ctx.http.fetch(`${baseUrl}/v1/rounds/open`, {
+  //     secretHeaders: { authorization: "apiKey" },
+  //   });
+  ctx.logger.info("__PLUGIN_KEY__.reconcile_completed");
+}

package/templates/provider-skeleton/src/handlers/routes.ts

@@ -0,0 +1,128 @@
+import { z } from "zod";
+import type { PluginContext, PluginRequest } from "@clovnet/plugin-sdk";
+import { PROVIDER_KEY, WALLET_PLACE_BET, WALLET_SETTLE_BET, WALLET_ROLLBACK_BET } from "../adapter.js";
+
+/**
+ * The inbound provider webhook — the latency-sensitive money path.
+ * Signature verification comes FIRST, then wallet commands with provider tx
+ * ids as idempotency keys: a replayed callback can never double-move money.
+ * Exercise it locally with:
+ *   cwe-plugin invoke POST /tx --surface callback --body '{"type":"wager",...}'
+ * (the route console skips the signature in the sandbox).
+ */
+export const txCallbackBodySchema = z
+  .object({
+    type: z.enum(["wager", "result", "rollback"]),
+    playerId: z.string().min(1).max(64),
+    roundId: z.string().min(1).max(128),
+    gameKey: z.string().min(1).max(128).optional(),
+    amount: z
+      .string()
+      .regex(/^\d+(\.\d{1,4})?$/)
+      .optional(),
+    currency: z.string().length(3).optional(),
+    providerTxId: z.string().min(1).max(128),
+    /** rollback: the providerTxId of the wager being reversed. */
+    refTxId: z.string().min(1).max(128).optional(),
+  })
+  .strict();
+
+interface MovementLike {
+  transactionId: string;
+  legs: Array<{ balanceAfter: string }>;
+}
+
+export async function txCallback(req: PluginRequest, ctx: PluginContext) {
+  await req.verifySignature("callbackSigningSecret");
+  const body = req.body as z.infer<typeof txCallbackBodySchema>;
+
+  switch (body.type) {
+    case "wager": {
+      if (!body.amount || !body.currency) {
+        return { status: 400, body: { error: { code: "MISSING_AMOUNT" } } };
+      }
+      const result = await ctx.commands.execute<MovementLike>({
+        name: WALLET_PLACE_BET,
+        input: {
+          playerId: body.playerId,
+          amount: Number(body.amount),
+          currency: body.currency,
+          provider: PROVIDER_KEY,
+          roundId: body.roundId,
+          externalTransactionId: body.providerTxId,
+          idempotencyKey: `${PROVIDER_KEY}:${body.providerTxId}`,
+        },
+      });
+      return {
+        body: {
+          status: "ok",
+          transactionId: result.transactionId,
+          balance: result.legs[0]?.balanceAfter ?? "0.0000",
+        },
+      };
+    }
+
+    case "result": {
+      if (!body.amount || !body.currency) {
+        return { status: 400, body: { error: { code: "MISSING_AMOUNT" } } };
+      }
+      const result = await ctx.commands.execute<MovementLike>({
+        name: WALLET_SETTLE_BET,
+        input: {
+          playerId: body.playerId,
+          amount: Number(body.amount),
+          currency: body.currency,
+          provider: PROVIDER_KEY,
+          roundId: body.roundId,
+          externalTransactionId: body.providerTxId,
+          idempotencyKey: `${PROVIDER_KEY}:${body.providerTxId}`,
+        },
+      });
+      await ctx.events.emit({
+        name: "plugin.__PLUGIN_KEY__.round_completed",
+        payload: { roundId: body.roundId, playerId: body.playerId, payout: body.amount },
+      });
+      return {
+        body: {
+          status: "ok",
+          transactionId: result.transactionId,
+          balance: result.legs[0]?.balanceAfter ?? "0.0000",
+        },
+      };
+    }
+
+    case "rollback": {
+      if (!body.refTxId) return { status: 400, body: { error: { code: "MISSING_REF_TX" } } };
+      // Resolve the original bet through the scoped read model (bets:read).
+      const round = await ctx.data.query("bets.byRound", {
+        source: PROVIDER_KEY,
+        externalTransactionId: body.refTxId,
+      });
+      const bet = round.bets.find((b) => b.type === "bet");
+      if (!bet) return { status: 404, body: { error: { code: "BET_NOT_FOUND" } } };
+      const result = await ctx.commands.execute<MovementLike>({
+        name: WALLET_ROLLBACK_BET,
+        input: {
+          transactionId: bet.transactionId,
+          reason: "provider_rollback",
+          idempotencyKey: `rollback:${bet.transactionId}`,
+        },
+      });
+      return {
+        body: {
+          status: "ok",
+          transactionId: result.transactionId,
+          balance: result.legs[0]?.balanceAfter ?? "0.0000",
+        },
+      };
+    }
+  }
+}
+
+/** Public health/lobby placeholder — replace with your game catalog surface. */
+export const statusOutputSchema = z.object({ provider: z.string(), operational: z.boolean() });
+
+export async function providerStatus(_req: PluginRequest, ctx: PluginContext) {
+  const { baseUrl } = ctx.settings.get<{ baseUrl?: string }>();
+  return { body: { provider: PROVIDER_KEY, operational: Boolean(baseUrl) } };
+}

package/templates/provider-skeleton/src/index.ts

@@ -0,0 +1,83 @@
+import { definePlugin } from "@clovnet/plugin-sdk";
+import { settings } from "./settings.js";
+import { PROVIDER_KEY, ProviderSkeletonAdapter, WALLET_PLACE_BET, WALLET_ROLLBACK_BET, WALLET_SETTLE_BET } from "./adapter.js";
+import { FakeProviderBackend } from "./fake-backend.js";
+import { onConfigure, onDisable, onEnable, onInstall, onUninstall } from "./handlers/hooks.js";
+import { providerStatus, statusOutputSchema, txCallback, txCallbackBodySchema } from "./handlers/routes.js";
+import { reconcile } from "./handlers/jobs.js";
+
+/**
+ * __PLUGIN_NAME__ — scaffolded from the `provider-skeleton` template: a game
+ * provider adapter (launch/bet/settle/rollback normalized into wallet
+ * commands), a signature-verified transaction callback and a fake backend so
+ * the whole money path is exercisable before any real API exists.
+ */
+export default definePlugin({
+  manifest: {
+    key: "__PLUGIN_KEY__",
+    name: "__PLUGIN_NAME__",
+    author: "you",
+    version: "0.1.0",
+    kind: "provider",
+    runtimeCompat: ">=0.1.0 <0.2.0",
+    description:
+      "Provider integration skeleton: game launch, bets, settlements and rollbacks — money moves only via wallet commands.",
+    permissions: {
+      commands: [WALLET_PLACE_BET, WALLET_SETTLE_BET, WALLET_ROLLBACK_BET],
+      events: {
+        subscribe: [],
+        emit: ["plugin.__PLUGIN_KEY__.round_completed"],
+      },
+      // bets:read powers the rollback path (resolve the original bet).
+      dataScopes: ["bets:read"],
+      providerKeys: [PROVIDER_KEY],
+    },
+    settings,
+    provider: {
+      providerKey: PROVIDER_KEY,
+      capabilities: ["launch", "balance", "bet", "settle", "rollback", "closeRound"],
+    },
+    hooks: {
+      onInstall: true,
+      onEnable: true,
+      onConfigure: true,
+      onDisable: true,
+      onUninstall: true,
+    },
+    // Outbound HTTP is allowlisted by host — everything else is egress-denied.
+    network: { allowedHosts: ["api.__PLUGIN_KEY__.example", "*.__PLUGIN_KEY__.example"] },
+    routes: [
+      {
+        method: "GET",
+        path: "/status",
+        surface: "public",
+        handler: "provider-status",
+        output: statusOutputSchema,
+        rateLimit: { windowSec: 60, max: 120 },
+      },
+      {
+        method: "POST",
+        path: "/tx",
+        surface: "callback",
+        handler: "tx-callback",
+        input: { body: txCallbackBodySchema },
+      },
+    ],
+    jobs: {
+      reconcile: { schedule: "0 4 * * *", handler: "reconcile", timeoutSec: 600 },
+    },
+  },
+  hooks: { onInstall, onEnable, onConfigure, onDisable, onUninstall },
+  handlers: {
+    routes: { "provider-status": providerStatus, "tx-callback": txCallback },
+    jobs: { reconcile },
+  },
+  setup: (ctx) => {
+    const { baseUrl, operatorId } = ctx.settings.get<{ baseUrl?: string; operatorId?: string }>();
+    const backend = new FakeProviderBackend({
+      baseUrl: baseUrl ?? "https://api.__PLUGIN_KEY__.example",
+      operatorId: operatorId ?? "op-demo",
+    });
+    ctx.registerProviderAdapter?.(new ProviderSkeletonAdapter(ctx, backend));
+  },
+});

package/templates/provider-skeleton/src/settings.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { settingsField, type PluginSettingsSchema } from "@clovnet/plugin-sdk";
+
+/**
+ * Provider credentials + endpoints. Both secrets are write-only: stored
+ * encrypted, injected server-side (`secretHeaders`) or read via
+ * `ctx.secrets.get(...)` — they never appear in logs or API responses.
+ */
+export const settings: PluginSettingsSchema = {
+  fields: {
+    baseUrl: settingsField.string({
+      label: "API base URL",
+      description: "The provider API endpoint the adapter calls.",
+      required: true,
+      default: "https://api.__PLUGIN_KEY__.example",
+      zod: z.string().url(),
+    }),
+    operatorId: settingsField.string({
+      label: "Operator ID",
+      description: "Your operator account with the provider.",
+      required: true,
+      default: "op-demo",
+    }),
+    apiKey: settingsField.string({
+      label: "API key",
+      description: "Provider API key. Write-only.",
+      required: true,
+      secret: true,
+    }),
+    callbackSigningSecret: settingsField.string({
+      label: "Callback signing secret",
+      description: "HMAC secret used to verify provider callbacks. Write-only.",
+      required: true,
+      secret: true,
+    }),
+  },
+};

package/templates/provider-skeleton/test/hooks.test.ts

@@ -0,0 +1,83 @@
+import { describe, expect, it } from "vitest";
+import { createTestContext } from "@clovnet/plugin-sdk/testing";
+import type { PluginRequest } from "@clovnet/plugin-sdk";
+import plugin from "../src/index.js";
+import { txCallback } from "../src/handlers/routes.js";
+
+/**
+ * Unit tests for the money path — wallet commands are canned + recorded by
+ * the in-memory test context (they NEVER execute), while the same
+ * permission/idempotency discipline as production applies.
+ */
+const asRequest = (partial: Partial<PluginRequest>): PluginRequest =>
+  ({
+    params: {},
+    query: {},
+    headers: {},
+    // The test context's verifySignature honors trustSignature-style fakes;
+    // for direct handler calls we stub it as verified.
+    verifySignature: async () => {},
+    ...partial,
+  }) as unknown as PluginRequest;
+
+function makeContext() {
+  return createTestContext(plugin, {
+    tenantId: "t-test",
+    settings: { baseUrl: "https://api.__PLUGIN_KEY__.example", operatorId: "op-demo" },
+    secrets: { apiKey: "test-key", callbackSigningSecret: "test-secret" },
+    commandResults: {
+      "wallet.bet.place": { transactionId: "tx_bet_1", legs: [{ balanceAfter: "95.0000" }] },
+      "wallet.bet.settle": { transactionId: "tx_settle_1", legs: [{ balanceAfter: "105.0000" }] },
+      "wallet.bet.rollback": { transactionId: "tx_rb_1", legs: [{ balanceAfter: "100.0000" }] },
+    },
+  });
+}
+
+describe("__PLUGIN_KEY__", () => {
+  it("blocks enable until the apiKey secret is saved", async () => {
+    const bare = createTestContext(plugin, { tenantId: "t-test", settings: {} });
+    await expect(bare.runHook("onEnable")).rejects.toThrow(/apiKey/);
+  });
+
+  it("wager callback dispatches wallet.bet.place with the provider tx id as idempotency key", async () => {
+    const t = makeContext();
+    const response = await txCallback(
+      asRequest({
+        body: {
+          type: "wager",
+          playerId: "p1",
+          roundId: "r1",
+          amount: "5.0000",
+          currency: "EUR",
+          providerTxId: "ptx_1",
+        },
+      }),
+      t.ctx,
+    );
+    expect(response.body).toMatchObject({ status: "ok", balance: "95.0000" });
+    expect(t.recorder.commands).toHaveLength(1);
+    expect(t.recorder.commands[0]).toMatchObject({ name: "wallet.bet.place" });
+    const input = t.recorder.commands[0]?.input as { idempotencyKey: string; externalTransactionId: string };
+    expect(input.idempotencyKey).toBe("__PLUGIN_KEY__:ptx_1");
+    expect(input.externalTransactionId).toBe("ptx_1");
+  });
+
+  it("settlement emits the round_completed event", async () => {
+    const t = makeContext();
+    await txCallback(
+      asRequest({
+        body: {
+          type: "result",
+          playerId: "p1",
+          roundId: "r1",
+          amount: "10.0000",
+          currency: "EUR",
+          providerTxId: "ptx_2",
+        },
+      }),
+      t.ctx,
+    );
+    expect(t.recorder.events).toHaveLength(1);
+    expect(t.recorder.events[0]?.name).toBe("plugin.__PLUGIN_KEY__.round_completed");
+  });
+});

package/templates/provider-skeleton/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "verbatimModuleSyntax": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "types": ["node"]
+  },
+  "include": ["src", "test"]
+}