dfx 0.126.1 → 1.0.0

package/examples/.env.example

@@ -0,0 +1,5 @@
+DISCORD_BOT_TOKEN=xxx
+
+# For webhooks only
+DISCORD_APP_ID=xxx
+DISCORD_PUBLIC_KEY=xxx

package/examples/interactions.ts

@@ -0,0 +1,79 @@
+import { NodeHttpClient, NodeSocket } from "@effect/platform-node"
+import { Discord, DiscordConfig, Ix } from "dfx"
+import { DiscordLive, runIx } from "dfx/gateway"
+import Dotenv from "dotenv"
+import { Config, Effect, Layer, pipe } from "effect"
+
+Dotenv.config()
+
+// Create the dependencies layer
+const DiscordConfigLive = DiscordConfig.layerConfig({
+  token: Config.redacted("DISCORD_BOT_TOKEN"),
+})
+
+// Create your interaction definitions.
+// Here we are creating a global application command.
+const hello = Ix.global(
+  {
+    name: "hello",
+    description: "A basic command",
+  },
+  Effect.succeed({
+    type: 4,
+    data: {
+      content: "Hello!",
+    },
+  }),
+)
+
+// Optionally use the type safe helpers
+const greeting = Ix.global(
+  {
+    name: "greeting",
+    description: "A basic command",
+    options: [
+      {
+        type: Discord.ApplicationCommandOptionType.STRING,
+        name: "who",
+        description: "who to greet",
+        required: true,
+      },
+      {
+        type: Discord.ApplicationCommandOptionType.STRING,
+        name: "greeting",
+        description: "What kind of greeting?",
+      },
+    ],
+  },
+  ix =>
+    Effect.succeed({
+      type: 4,
+      data: {
+        content: `${ix.optionValueOrElse("greeting", () => "Hello")} ${ix.optionValue("who")}!`,
+      },
+      // fail: ix.optionValue("fail"), // <- this would be a type error
+    }),
+)
+
+// Build your program use `Ix.builder`
+const program = Effect.gen(function* () {
+  const interactions = pipe(
+    Ix.builder.add(hello).add(greeting),
+    runIx(Effect.catch(e => Effect.logError("CAUGHT INTERACTION ERROR", e))),
+  )
+
+  yield* Effect.asVoid(interactions)
+})
+
+const EnvLive = DiscordLive.pipe(
+  Layer.provide(NodeHttpClient.layerUndici),
+  Layer.provide(NodeSocket.layerWebSocketConstructor),
+  Layer.provide(DiscordConfigLive),
+)
+
+// Run it
+program.pipe(
+  Effect.provide(EnvLive),
+  Effect.tapCause(Effect.logError),
+  Effect.runFork,
+)

package/examples/readme.ts

@@ -0,0 +1,56 @@
+import { NodeHttpClient, NodeRuntime, NodeSocket } from "@effect/platform-node"
+import { DiscordConfig, Ix } from "dfx"
+import { DiscordIxLive, InteractionsRegistry } from "dfx/gateway"
+import * as Dotenv from "dotenv"
+import { Config, Effect, Layer } from "effect"
+
+Dotenv.config()
+
+// Create a layer for the discord services
+const DiscordLayer = DiscordIxLive.pipe(
+  Layer.provide([
+    DiscordConfig.layerConfig({
+      token: Config.redacted("DISCORD_BOT_TOKEN"),
+    }),
+    NodeHttpClient.layerUndici,
+    NodeSocket.layerWebSocketConstructor,
+  ]),
+)
+
+// Create hello service
+const HelloLayer = Layer.effectDiscard(
+  Effect.gen(function* () {
+    const registry = yield* InteractionsRegistry
+
+    // Create hello command that responds with "Hello!"
+    const hello = Ix.global(
+      {
+        name: "hello",
+        description: "A basic command",
+      },
+      Effect.succeed({
+        type: 4,
+        data: {
+          content: "Hello!",
+        },
+      }),
+    )
+
+    // register the command(s) and handle errors
+    yield* registry.register(
+      Ix.builder.add(hello).catchAllCause(Effect.logError),
+    )
+  }),
+).pipe(
+  // provide discord layer
+  Layer.provide(DiscordLayer),
+)
+
+// Construct the main layer
+const MainLive = Layer.mergeAll(
+  // add your other services here
+  HelloLayer,
+)
+
+// run it
+NodeRuntime.runMain(Layer.launch(MainLive))

package/examples/registry.ts

@@ -0,0 +1,66 @@
+import { NodeHttpClient, NodeRuntime, NodeSocket } from "@effect/platform-node"
+import { Discord, DiscordConfig, Ix, UI } from "dfx"
+import { DiscordIxLive, InteractionsRegistry } from "dfx/gateway"
+import Dotenv from "dotenv"
+import { Config, Effect, Layer } from "effect"
+
+Dotenv.config()
+
+// Create your service and register your interactions
+const makeGreetService = Effect.gen(function* () {
+  const registry = yield* InteractionsRegistry
+
+  const greet = Ix.global(
+    {
+      name: "greet",
+      description: "A basic command",
+      options: [
+        {
+          name: "name",
+          description: "who to greet",
+          type: Discord.ApplicationCommandOptionType.STRING,
+          required: true,
+        },
+      ],
+    },
+    ix =>
+      Effect.succeed(
+        Ix.response({
+          type: Discord.InteractionCallbackTypes.CHANNEL_MESSAGE_WITH_SOURCE,
+          data: UI.components([
+            UI.textDisplay(`Hello ${ix.optionValue("name")}!`),
+            UI.row([
+              UI.button({ custom_id: "one", label: "Click me!" }),
+              UI.button({ custom_id: "two", label: "Click me 2!" }),
+            ]),
+          ]),
+        }),
+      ),
+  )
+
+  // create a builder
+  const ix = Ix.builder.add(greet).catchAllCause(Effect.logError)
+
+  // register the interactions
+  yield* registry.register(ix)
+})
+
+// Greet service layer
+const GreetLive = Layer.effectDiscard(makeGreetService)
+
+// Main layer
+const MainLive = GreetLive.pipe(
+  Layer.provide(DiscordIxLive),
+  Layer.provide(NodeHttpClient.layerUndici),
+  Layer.provide(NodeSocket.layerWebSocketConstructor),
+  Layer.provide(
+    DiscordConfig.layerConfig({
+      token: Config.redacted("DISCORD_BOT_TOKEN"),
+    }),
+  ),
+)
+
+Layer.launch(MainLive).pipe(
+  Effect.catchCause(Effect.logError),
+  NodeRuntime.runMain,
+)

package/flake.lock

@@ -0,0 +1,27 @@
+{
+  "nodes": {
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1747060738,
+        "narHash": "sha256-ByfPRQuqj+nhtVV0koinEpmJw0KLzNbgcgi9EF+NVow=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "eaeed9530c76ce5f1d2d8232e08bec5e26f18ec1",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "ref": "nixpkgs-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "nixpkgs": "nixpkgs"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

package/flake.nix

@@ -0,0 +1,21 @@
+{
+  inputs = {
+    nixpkgs.url = "github:nixos/nixpkgs/nixpkgs-unstable";
+  };
+  outputs = {nixpkgs, ...}: let
+    forAllSystems = function:
+      nixpkgs.lib.genAttrs nixpkgs.lib.systems.flakeExposed (
+        system: function nixpkgs.legacyPackages.${system}
+      );
+  in {
+    formatter = forAllSystems (pkgs: pkgs.alejandra);
+    devShells = forAllSystems (pkgs: {
+      default = pkgs.mkShell {
+        packages = with pkgs; [
+          corepack
+          nodejs
+        ];
+      };
+    });
+  };
+}

package/lerna.json

@@ -0,0 +1,12 @@
+{
+  "packages": ["."],
+  "version": "independent",
+  "npmClient": "pnpm",
+  "command": {
+    "version": {
+      "allowBranch": "main",
+      "conventionalCommits": true,
+      "createRelease": "github"
+    }
+  }
+}

package/package.json

@@ -1,49 +1,92 @@
 {
   "name": "dfx",
-  "version": "0.126.1",
+  "version": "1.0.0",
+  "packageManager": "pnpm@10.11.0+sha512.6540583f41cc5f628eb3d9773ecee802f4f9ef9923cc45b69890fb47991d4b092964694ec3a4f738a420c918a333062c8b925d312f42e4f0c263eb603551f977",
+  "type": "module",
+  "publishConfig": {
+    "access": "public",
+    "directory": "dist"
+  },
   "description": "Effect-TS discord library",
-  "license": "MIT",
+  "author": "Tim Smart <hello@timsmart.co>",
   "repository": {
     "type": "git",
     "url": "https://github.com/tim-smart/dfx.git"
   },
-  "publishConfig": {
-    "access": "public"
-  },
-  "exports": {
-    "./*": {
-      "import": {
-        "types": "./*.d.ts",
-        "default": "./mjs/*.mjs"
-      },
-      "require": {
-        "types": "./*.d.ts",
-        "default": "./*.js"
-      }
-    },
-    ".": {
-      "import": {
-        "types": "./index.d.ts",
-        "default": "./mjs/index.mjs"
-      },
-      "require": {
-        "types": "./index.d.ts",
-        "default": "./index.js"
-      }
-    }
-  },
-  "sideEffects": [],
-  "author": "Tim Smart <hello@timsmart.co>",
-  "dependencies": {
-    "discord-api-types": "^0.38.26"
+  "license": "MIT",
+  "scripts": {
+    "example": "ts-node --project tsconfig.examples.json",
+    "prepublishOnly": "pnpm build",
+    "types": "./scripts/generate-client.sh",
+    "clean": "rimraf build tsbuildinfo dist .cache",
+    "prebuild": "node -p \"'export const LIB_VERSION = ' + JSON.stringify(require('./package.json').version) + ';'\" > src/version.ts",
+    "build": "pnpm prebuild && pnpm build-all && pnpm build-pack",
+    "build-cjs": "babel build/esm --config-file ./.babel.cjs.json --out-dir build/cjs --out-file-extension .js --source-maps",
+    "build-mjs": "babel build/esm --config-file ./.babel.mjs.json --out-dir build/mjs --out-file-extension .mjs --source-maps",
+    "build-post": "build-utils pack-v1",
+    "build-pack": "concurrently \"pnpm build-cjs\" \"pnpm build-mjs\" && pnpm build-post",
+    "build-all": "tsc -b tsconfig.json",
+    "build-watch": "tsc -b tsconfig.json --watch",
+    "check": "pnpm lint && pnpm tsgo -b tsconfig.json",
+    "lint": "oxlint src test examples",
+    "autofix": "pnpm lint --fix",
+    "circular": "madge --ts-config ./tsconfig.madge.json --circular --no-color --no-spinner --warning build/esm",
+    "test": "vitest",
+    "coverage": "vitest run --coverage",
+    "prepare": "husky && effect-language-service patch"
   },
   "peerDependencies": {
-    "@effect/platform": "^0.92",
-    "effect": "^3.18"
+    "effect": "4.0.0-beta.6"
   },
   "optionalDependencies": {
     "discord-verify": "^1.2.0"
   },
-  "gitHead": "45e9bdbc303d77f39da3d5a93e284c8173db322f",
-  "main": "./index.js"
-}
+  "devDependencies": {
+    "@babel/cli": "^7.28.6",
+    "@babel/core": "^7.29.0",
+    "@babel/plugin-syntax-import-attributes": "^7.28.6",
+    "@babel/plugin-transform-modules-commonjs": "^7.28.6",
+    "@changesets/changelog-github": "^0.5.2",
+    "@changesets/cli": "^2.29.8",
+    "@effect/babel-plugin": "^0.2.0",
+    "@effect/build-utils": "^0.8.9",
+    "@effect/language-service": "^0.74.0",
+    "@effect/platform-node": "4.0.0-beta.6",
+    "@tim-smart/openapi-gen": "^1.0.0",
+    "@types/chai": "^5.2.3",
+    "@types/node": "^25.2.3",
+    "@types/ws": "^8.18.1",
+    "@typescript/native-preview": "7.0.0-dev.20260219.1",
+    "@vitejs/plugin-react": "^5.1.4",
+    "@vitest/coverage-v8": "^4.0.18",
+    "babel-plugin-annotate-pure-calls": "^0.5.0",
+    "concurrently": "^9.2.1",
+    "dotenv": "^17.3.1",
+    "effect": "4.0.0-beta.6",
+    "husky": "^9.1.7",
+    "lerna": "^9.0.4",
+    "lint-staged": "^16.2.7",
+    "madge": "^8.0.0",
+    "oxlint": "^1.48.0",
+    "prettier": "^3.8.1",
+    "rimraf": "^6.1.3",
+    "ts-node": "^10.9.2",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vite": "^7.3.1",
+    "vitest": "4.0.18"
+  },
+  "gitHead": "8f299caa1306c17bef8fa3bd2528bda36e55c462",
+  "dependencies": {
+    "discord-api-types": "^0.38.39"
+  },
+  "lint-staged": {
+    "*.{ts,tsx}": [
+      "oxlint --fix",
+      "prettier --write"
+    ],
+    "*.{json,md,yml,yaml}": [
+      "prettier --write"
+    ]
+  }
+}

package/pnpm-workspace.yaml

@@ -0,0 +1,7 @@
+ignoredBuiltDependencies:
+  - esbuild
+onlyBuiltDependencies:
+  - '@parcel/watcher'
+  - msgpackr-extract
+  - nx
+  - unrs-resolver

package/scripts/generate-client.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+mkdir -p tmp
+curl https://raw.githubusercontent.com/discord/discord-api-spec/refs/heads/main/specs/openapi.json -o tmp/openapi.json
+pnpm openapi-gen -n DiscordRest -s tmp/openapi.json > src/DiscordREST/Generated.ts
+
+echo "// oxlint-disable no-shadow
+$(cat src/DiscordREST/Generated.ts)" > src/DiscordREST/Generated.ts
+
+pnpm prettier -w src/DiscordREST/Generated.ts

package/scripts/worktree-setup.sh

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+direnv allow
+corepack install
+pnpm install
+
+git clone https://github.com/effect-ts/effect-smol.git --depth 1 .repos/effect

package/src/Cache/memory.ts

@@ -1,7 +1,7 @@
 import * as Option from "effect/Option"
 import * as Effect from "effect/Effect"
-import type { CacheDriver, ParentCacheDriver } from "dfx/Cache/driver"
-import { createDriver, createParentDriver } from "dfx/Cache/driver"
+import type { CacheDriver, ParentCacheDriver } from "./driver.ts"
+import { createDriver, createParentDriver } from "./driver.ts"
 
 export const createWithParent = <T>(): Effect.Effect<
   ParentCacheDriver<never, T>
@@ -24,11 +24,11 @@ export const createWithParent = <T>(): Effect.Effect<
       get: (parentId, resourceId) =>
         Effect.sync(
           (): Option.Option<T> =>
-            Option.fromNullable(map.get(parentId)?.get(resourceId)),
+            Option.fromNullishOr(map.get(parentId)?.get(resourceId)),
         ),
 
       getForParent: parentId =>
-        Effect.sync(() => Option.fromNullable(map.get(parentId))),
+        Effect.sync(() => Option.fromNullishOr(map.get(parentId))),
 
       set: (parentId, resourceId, resource) =>
         Effect.sync(() => {
@@ -63,7 +63,7 @@ export const create = <T>(): Effect.Effect<CacheDriver<never, T>> =>
 
       get: resourceId =>
         Effect.sync(
-          (): Option.Option<T> => Option.fromNullable(map.get(resourceId)),
+          (): Option.Option<T> => Option.fromNullishOr(map.get(resourceId)),
         ),
 
       set: (resourceId, resource) =>

package/src/Cache/memoryTTL.ts

@@ -1,10 +1,14 @@
-import type { CacheDriver, ParentCacheDriver } from "dfx/Cache/driver"
-import { createDriver, createParentDriver } from "dfx/Cache/driver"
+import type { CacheDriver, ParentCacheDriver } from "./driver.ts"
+import { createDriver, createParentDriver } from "./driver.ts"
 import * as Array from "effect/Array"
 import * as Duration from "effect/Duration"
 import * as Effect from "effect/Effect"
 import * as Option from "effect/Option"
 
+declare const global: typeof globalThis & {
+  gc?: () => void
+}
+
 export interface MemoryTTLOpts {
   /** The approx. number of milliseconds to keep items */
   readonly ttl: Duration.Duration
@@ -99,7 +103,7 @@ const make = <T>({
 
     get: resourceId =>
       Effect.sync(
-        (): Option.Option<T> => Option.fromNullable(getSync(resourceId)),
+        (): Option.Option<T> => Option.fromNullishOr(getSync(resourceId)),
       ),
 
     refreshTTL: id =>
@@ -153,7 +157,7 @@ export const createWithParent = <T>(
       get: (_, id) => store.get(id),
 
       getForParent: parentId =>
-        Option.fromNullable(parentIds.get(parentId)).pipe(
+        Effect.fromNullishOr(parentIds.get(parentId)).pipe(
           Effect.flatMap(ids =>
             Effect.forEach(
               ids,
@@ -176,11 +180,11 @@ export const createWithParent = <T>(
               item._tag === "Some" ? acc.set(id, item.value) : acc,
             ),
           ),
-          Effect.option,
+          Effect.catchNoSuchElement,
         ),
 
       set: (parentId, resourceId, resource) =>
-        Effect.zipRight(
+        Effect.andThen(
           store.set(resourceId, resource),
           Effect.sync(() => {
             if (!parentIds.has(parentId)) {
@@ -191,7 +195,7 @@ export const createWithParent = <T>(
         ),
 
       delete: (parentId, resourceId) =>
-        Effect.zipRight(
+        Effect.andThen(
           store.delete(resourceId),
           Effect.sync(() => {
             parentIds.get(parentId)?.delete(resourceId)

package/src/Cache/prelude.ts

@@ -1,8 +1,8 @@
 import * as Effect from "effect/Effect"
 import type * as Scope from "effect/Scope"
 import * as Stream from "effect/Stream"
-import type { DiscordRESTError } from "dfx/DiscordREST"
-import { DiscordREST } from "dfx/DiscordREST"
+import type { DiscordRESTError } from "../DiscordREST.ts"
+import { DiscordREST } from "../DiscordREST.ts"
 import type {
   CacheDriver,
   CacheOp,
@@ -10,10 +10,10 @@ import type {
   ParentCacheOp,
   Cache,
   ParentCache,
-} from "dfx/Cache"
-import { CacheMissError, make, makeWithParent } from "dfx/Cache"
-import { DiscordGateway } from "dfx/DiscordGateway"
-import type * as Discord from "dfx/types"
+} from "../Cache.ts"
+import { CacheMissError, make, makeWithParent } from "../Cache.ts"
+import { DiscordGateway } from "../DiscordGateway.ts"
+import type * as Discord from "../types.ts"
 
 export interface OptsWithParentOptions<E, A> {
   readonly id: (a: A) => string
@@ -210,8 +210,10 @@ export const channels = <RM, EM, E>(
       }),
       onMiss: (_, id) => rest.getChannel(id),
       onParentMiss: guildId =>
-        Effect.map(rest.listGuildChannels(guildId), a =>
-          a.map(a => [a.id, a as Discord.GetChannel200] as const),
+        Effect.map(rest.listGuildChannels(guildId), guildChannels =>
+          guildChannels.map(
+            channel => [channel.id, channel as Discord.GetChannel200] as const,
+          ),
         ),
     })
   })