@shivaedev/discord 0.0.0 → 0.2.0

package/dist/request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request.d.ts","sourceRoot":"","sources":["../src/request.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AACxC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAGzD,wBAAgB,OAAO,CAAC,OAAO,SAAS,MAAM,CAAC,iBAAiB,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,OAAO,6nBAE3I"}

package/dist/request.js

@@ -0,0 +1,6 @@
+import { Effect, Schema } from "effect";
+import { DiscordRest } from "#DiscordRest.ts";
+export function request(method, path, schema, body) {
+    return Effect.flatMap(DiscordRest, (rest) => rest.request(method, path, body)).pipe(Effect.flatMap(Schema.decodeUnknownEffect(schema)));
+}
+//# sourceMappingURL=request.js.map

package/dist/request.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request.js","sourceRoot":"","sources":["../src/request.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAExC,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAE9C,MAAM,UAAU,OAAO,CAAoD,MAAkB,EAAE,IAAY,EAAE,MAAe,EAAE,IAAc;IAC3I,OAAO,MAAM,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;AACzI,CAAC"}

package/dist/restClient.d.ts

@@ -0,0 +1,11 @@
+import { Effect, Schema, Semaphore } from "effect";
+import { HttpClient } from "effect/http";
+import type { HttpMethod } from "effect/http/HttpMethod";
+import { DiscordToken } from "#DiscordToken.ts";
+import { DiscordRateLimited, DiscordTransportError } from "#errors.ts";
+export declare const initializeRest: Effect.Effect<{
+    lock: Semaphore.Semaphore;
+    request: (method: HttpMethod, path: string, body?: unknown) => Effect.Effect<unknown, DiscordRateLimited | import("effect/http/HttpBody").HttpBodyError | import("effect/http/HttpClientError").HttpClientError | import("@shivaedev/http/errors.ts").InvalidBodyLimit | import("@shivaedev/http/errors.ts").RemoteGone | import("@shivaedev/http/errors.ts").RemoteHttpError | import("@shivaedev/http/errors.ts").RemoteNotFound | import("@shivaedev/http/errors.ts").RemoteRateLimited | import("@shivaedev/http/errors.ts").RemoteUnauthorized | import("@shivaedev/http/errors.ts").ResponseBodyTooLarge | Schema.SchemaError, never>;
+}, never, DiscordToken | HttpClient.HttpClient>;
+export declare function restRequest(state: Effect.Success<typeof initializeRest>): (method: HttpMethod, path: string, body?: unknown) => Effect.Effect<unknown, DiscordRateLimited | DiscordTransportError | import("effect/http/HttpBody").HttpBodyError | import("@shivaedev/http/errors.ts").InvalidBodyLimit | import("@shivaedev/http/errors.ts").RemoteGone | import("@shivaedev/http/errors.ts").RemoteHttpError | import("@shivaedev/http/errors.ts").RemoteNotFound | import("@shivaedev/http/errors.ts").RemoteRateLimited | import("@shivaedev/http/errors.ts").RemoteUnauthorized | import("@shivaedev/http/errors.ts").ResponseBodyTooLarge | Schema.SchemaError, never>;
+//# sourceMappingURL=restClient.d.ts.map

package/dist/restClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"restClient.d.ts","sourceRoot":"","sources":["../src/restClient.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAY,MAAM,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;AAC7D,OAAO,EAAE,UAAU,EAAqB,MAAM,aAAa,CAAC;AAC5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAMzD,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAOvE,eAAO,MAAM,cAAc;;;+CAuCzB,CAAC;AAEH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,CAAC,OAAO,CAAC,OAAO,cAAc,CAAC,YACvD,UAAU,QAAQ,MAAM,SAAS,OAAO,khBAKxD"}

package/dist/restClient.js

@@ -0,0 +1,51 @@
+import { Effect, Redacted, Schema, Semaphore } from "effect";
+import { HttpClient, HttpClientRequest } from "effect/http";
+import { readBoundedJson } from "@shivaedev/http/body.ts";
+import { checkStatus } from "@shivaedev/http/checkStatus.ts";
+import { isEmpty, isRateLimited } from "#adapters/restStatus.ts";
+import { routeKey } from "#adapters/routeKey.ts";
+import { DiscordConfig } from "#DiscordConfig.ts";
+import { DiscordToken } from "#DiscordToken.ts";
+import { DiscordRateLimited, DiscordTransportError } from "#errors.ts";
+import { rateLimits } from "#rateLimits.ts";
+const Limited = Schema.Struct({ global: Schema.optional(Schema.Boolean), retryAfter: Schema.Number }).pipe(Schema.encodeKeys({ retryAfter: "retry_after" }));
+export const initializeRest = Effect.gen(function* () {
+    const client = HttpClient.withScope(yield* HttpClient.HttpClient);
+    const token = yield* DiscordToken;
+    const config = yield* DiscordConfig;
+    const rates = rateLimits();
+    const lock = yield* Semaphore.make(1);
+    const request = Effect.fnUntraced(function* (method, path, body) {
+        const { major, route } = routeKey(method, path);
+        let input = HttpClientRequest.make(method)(`${config.apiUrl}${path}`).pipe(HttpClientRequest.setHeader("Authorization", `Bot ${Redacted.value(token)}`));
+        if (body !== undefined) {
+            input = yield* HttpClientRequest.bodyJson(input, body);
+        }
+        for (let attempt = 0;; attempt += 1) {
+            yield* rates.wait(route, major);
+            const answer = yield* Effect.scoped(Effect.gen(function* () {
+                const response = yield* client.execute(input);
+                yield* rates.observe(route, major, response.headers);
+                if (isRateLimited(response.status)) {
+                    const limit = yield* readBoundedJson(response, 64 * 1024, Limited);
+                    yield* rates.refuse(route, major, limit.retryAfter, limit.global === true);
+                    if (attempt === 3) {
+                        return yield* new DiscordRateLimited({ retryAfter: limit.retryAfter });
+                    }
+                    return { retry: true, value: undefined };
+                }
+                yield* checkStatus(response);
+                const value = isEmpty(response.status) ? undefined : yield* readBoundedJson(response, 1024 * 1024, Schema.Unknown);
+                return { retry: false, value };
+            }));
+            if (!answer.retry) {
+                return answer.value;
+            }
+        }
+    });
+    return { lock, request };
+});
+export function restRequest(state) {
+    return (method, path, body) => state.request(method, path, body).pipe(state.lock.withPermit, Effect.catchTag("HttpClientError", () => Effect.fail(new DiscordTransportError({}))));
+}
+//# sourceMappingURL=restClient.js.map

package/dist/restClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"restClient.js","sourceRoot":"","sources":["../src/restClient.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;AAC7D,OAAO,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAE5D,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAC7D,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AACvE,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAE5C,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,IAAI,CACzG,MAAM,CAAC,UAAU,CAAC,EAAE,UAAU,EAAE,aAAa,EAAE,CAAC,CAChD,CAAC;AAEF,MAAM,CAAC,MAAM,cAAc,GAAG,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IACjD,MAAM,MAAM,GAAG,UAAU,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC;IAClE,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,YAAY,CAAC;IAClC,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,aAAa,CAAC;IACpC,MAAM,KAAK,GAAG,UAAU,EAAE,CAAC;IAC3B,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACtC,MAAM,OAAO,GAAG,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,MAAkB,EAAE,IAAY,EAAE,IAAc;QAC5F,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QAChD,IAAI,KAAK,GAAG,iBAAiB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,GAAG,IAAI,EAAE,CAAC,CAAC,IAAI,CACzE,iBAAiB,CAAC,SAAS,CAAC,eAAe,EAAE,OAAO,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC,CAC5E,CAAC;QACF,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YACxB,KAAK,GAAG,KAAK,CAAC,CAAC,iBAAiB,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QACxD,CAAC;QACD,KAAK,IAAI,OAAO,GAAG,CAAC,GAAI,OAAO,IAAI,CAAC,EAAE,CAAC;YACtC,KAAK,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;YAChC,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,MAAM,CAAC,MAAM,CAClC,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;gBACnB,MAAM,QAAQ,GAAG,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;gBAC9C,KAAK,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;gBACrD,IAAI,aAAa,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;oBACpC,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,eAAe,CAAC,QAAQ,EAAE,EAAE,GAAG,IAAI,EAAE,OAAO,CAAC,CAAC;oBACnE,KAAK,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,MAAM,KAAK,IAAI,CAAC,CAAC;oBAC3E,IAAI,OAAO,KAAK,CAAC,EAAE,CAAC;wBACnB,OAAO,KAAK,CAAC,CAAC,IAAI,kBAAkB,CAAC,EAAE,UAAU,EAAE,KAAK,CAAC,UAAU,EAAE,CAAC,CAAC;oBACxE,CAAC;oBACD,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC;gBAC1C,CAAC;gBACD,KAAK,CAAC,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;gBAC7B,MAAM,KAAK,GAAG,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,eAAe,CAAC,QAAQ,EAAE,IAAI,GAAG,IAAI,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC;gBACnH,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;YAChC,CAAC,CAAC,CACF,CAAC;YACF,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;gBACnB,OAAO,MAAM,CAAC,KAAK,CAAC;YACrB,CAAC;QACF,CAAC;IACF,CAAC,CAAC,CAAC;IACH,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;AAC1B,CAAC,CAAC,CAAC;AAEH,MAAM,UAAU,WAAW,CAAC,KAA4C;IACvE,OAAO,CAAC,MAAkB,EAAE,IAAY,EAAE,IAAc,EAAE,EAAE,CAC3D,KAAK,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,IAAI,CACrC,KAAK,CAAC,IAAI,CAAC,UAAU,EACrB,MAAM,CAAC,QAAQ,CAAC,iBAAiB,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,qBAAqB,CAAC,EAAE,CAAC,CAAC,CAAC,CACpF,CAAC;AACJ,CAAC"}

package/dist/runGateway.d.ts

@@ -0,0 +1,6 @@
+import { Effect } from "effect";
+import { DiscordGatewayClosed } from "#errors.ts";
+import { GatewayTransport } from "#GatewayTransport.ts";
+import type { GatewayDispatch } from "#gatewayProtocol.ts";
+export declare const runGateway: (dispatch: (event: GatewayDispatch) => Effect.Effect<void>) => Effect.Effect<never, DiscordGatewayClosed | import("#errors.ts").DiscordGatewayProtocolError, import("./DiscordToken.ts").DiscordToken | GatewayTransport>;
+//# sourceMappingURL=runGateway.d.ts.map

package/dist/runGateway.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runGateway.d.ts","sourceRoot":"","sources":["../src/runGateway.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGhC,OAAO,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAExD,OAAO,KAAK,EAAE,eAAe,EAAkB,MAAM,qBAAqB,CAAC;AAE3E,eAAO,MAAM,UAAU,qBAAkD,eAAe,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,+JAuB9G,CAAC"}

package/dist/runGateway.js

@@ -0,0 +1,29 @@
+import { Effect } from "effect";
+import { Socket } from "effect/socket";
+import { DiscordConfig } from "#DiscordConfig.ts";
+import { DiscordGatewayClosed } from "#errors.ts";
+import { GatewayTransport } from "#GatewayTransport.ts";
+import { gatewayConnection } from "#gatewayConnection.ts";
+export const runGateway = Effect.fnUntraced(function* (dispatch) {
+    const config = yield* DiscordConfig;
+    const transport = yield* GatewayTransport;
+    const session = { resumeUrl: undefined, sequence: null, sessionId: undefined };
+    while (true) {
+        const socket = yield* transport.open(`${session.resumeUrl ?? config.gatewayUrl}/?v=10&encoding=json`);
+        yield* gatewayConnection(session, dispatch)
+            .pipe(Effect.provideService(Socket.Socket, socket))
+            .pipe(Effect.catchTag("SocketError", (error) => {
+            const code = error.reason._tag === "SocketCloseError" ? error.reason.code : undefined;
+            if (code === 4004 || (code !== undefined && code >= 4010 && code <= 4014)) {
+                return Effect.fail(new DiscordGatewayClosed({ code }));
+            }
+            if (code === 4007 || code === 4009) {
+                session.sessionId = undefined;
+                session.resumeUrl = undefined;
+                session.sequence = null;
+            }
+            return Effect.sleep("1 second");
+        }));
+    }
+});
+//# sourceMappingURL=runGateway.js.map

package/dist/runGateway.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runGateway.js","sourceRoot":"","sources":["../src/runGateway.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACvC,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAG1D,MAAM,CAAC,MAAM,UAAU,GAAG,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,QAAyD;IAC/G,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,aAAa,CAAC;IACpC,MAAM,SAAS,GAAG,KAAK,CAAC,CAAC,gBAAgB,CAAC;IAC1C,MAAM,OAAO,GAAmB,EAAE,SAAS,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAI,EAAE,SAAS,EAAE,SAAS,EAAE,CAAC;IAC/F,OAAO,IAAI,EAAE,CAAC;QACb,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,SAAS,IAAI,MAAM,CAAC,UAAU,sBAAsB,CAAC,CAAC;QACtG,KAAK,CAAC,CAAC,iBAAiB,CAAC,OAAO,EAAE,QAAQ,CAAC;aACzC,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;aAClD,IAAI,CACJ,MAAM,CAAC,QAAQ,CAAC,aAAa,EAAE,CAAC,KAAK,EAAE,EAAE;YACxC,MAAM,IAAI,GAAG,KAAK,CAAC,MAAM,CAAC,IAAI,KAAK,kBAAkB,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC;YACtF,IAAI,IAAI,KAAK,IAAI,IAAI,CAAC,IAAI,KAAK,SAAS,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,CAAC,EAAE,CAAC;gBAC3E,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,oBAAoB,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;YACxD,CAAC;YACD,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;gBACpC,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;gBAC9B,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;gBAC9B,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC;YACzB,CAAC;YACD,OAAO,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;QACjC,CAAC,CAAC,CACF,CAAC;IACJ,CAAC;AACF,CAAC,CAAC,CAAC"}

package/package.json

@@ -1,12 +1,71 @@
 {
   "name": "@shivaedev/discord",
-  "version": "0.0.0",
-  "description": "Name reserved for an upcoming ShivaeDev Platform package.",
-  "license": "MIT",
+  "version": "0.2.0",
+  "description": "Discord integrations for Effect applications",
+  "homepage": "https://github.com/ShivaeDev/platform/tree/main/packages/discord#readme",
+  "bugs": {
+    "url": "https://github.com/ShivaeDev/platform/issues"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ShivaeDev/platform.git",
     "directory": "packages/discord"
   },
-  "homepage": "https://github.com/ShivaeDev/platform/tree/main/packages/discord#readme"
+  "license": "MIT",
+  "sideEffects": false,
+  "type": "module",
+  "imports": {
+    "#test/*": "./src/test-support/*",
+    "#*.ts": {
+      "@shivaedev/source": "./src/*.ts",
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js"
+    }
+  },
+  "exports": {
+    "./*.ts": {
+      "@shivaedev/source": "./src/*.ts",
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "src",
+    "!src/**/*.test.ts",
+    "!src/**/*.spec.ts",
+    "!src/**/test-support",
+    "CHANGELOG.md",
+    "README.md"
+  ],
+  "dependencies": {
+    "@shivaedev/http": "0.6.0",
+    "@shivaedev/service": "0.7.0"
+  },
+  "devDependencies": {
+    "@shivaedev/quality": "0.60.0",
+    "@shivaedev/test-kits": "0.3.0",
+    "@shivaedev/test-story": "0.38.0",
+    "@types/node": "24.19.2",
+    "effect": "4.0.6",
+    "typescript": "7.0.2",
+    "vitest": "5.0.5"
+  },
+  "peerDependencies": {
+    "effect": "4.0.6"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "build": "node --eval \"import('node:fs').then(({ rmSync }) => rmSync('dist', { force: true, recursive: true }))\" && tsc --project tsconfig.build.json",
+    "ready": "pnpm typecheck && pnpm test && pnpm build",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
 }

package/src/DiscordConfig.ts

@@ -0,0 +1,9 @@
+import { Context } from "effect";
+
+export const DiscordConfig = Context.Reference<{
+	readonly apiUrl: string;
+	readonly gatewayUrl: string;
+	readonly intents: number;
+}>("@shivaedev/discord/DiscordConfig", {
+	defaultValue: () => ({ apiUrl: "https://discord.com/api/v10", gatewayUrl: "wss://gateway.discord.gg", intents: 0 }),
+});

package/src/DiscordGateway.ts

@@ -0,0 +1,13 @@
+import { Effect } from "effect";
+import { defineService } from "@shivaedev/service/defineService.ts";
+import { DiscordConfig } from "#DiscordConfig.ts";
+import { DiscordToken } from "#DiscordToken.ts";
+import { GatewayTransport } from "#GatewayTransport.ts";
+import { runGateway } from "#runGateway.ts";
+
+export const DiscordGateway = defineService({
+	id: "@shivaedev/discord/DiscordGateway",
+	initialize: Effect.void,
+	methods: () => ({ run: runGateway }),
+	requires: [DiscordConfig, DiscordToken, GatewayTransport],
+});

package/src/DiscordRest.ts

@@ -0,0 +1,12 @@
+import { HttpClient } from "effect/http";
+import { defineService } from "@shivaedev/service/defineService.ts";
+import { DiscordConfig } from "#DiscordConfig.ts";
+import { DiscordToken } from "#DiscordToken.ts";
+import { initializeRest, restRequest } from "#restClient.ts";
+
+export const DiscordRest = defineService({
+	id: "@shivaedev/discord/DiscordRest",
+	initialize: initializeRest,
+	methods: (state) => ({ request: restRequest(state) }),
+	requires: [HttpClient.HttpClient, DiscordToken, DiscordConfig],
+});

package/src/DiscordToken.ts

@@ -0,0 +1,3 @@
+import { Context, type Redacted } from "effect";
+
+export class DiscordToken extends Context.Service<DiscordToken, Redacted.Redacted<string>>()("@shivaedev/discord/DiscordToken") {}

package/src/GatewayTransport.ts

@@ -0,0 +1,9 @@
+import { Context, type Effect } from "effect";
+import type { Socket } from "effect/socket";
+
+export class GatewayTransport extends Context.Service<
+	GatewayTransport,
+	{
+		readonly open: (url: string) => Effect.Effect<Socket.Socket>;
+	}
+>()("@shivaedev/discord/GatewayTransport") {}

package/src/adapters/restStatus.ts

@@ -0,0 +1,9 @@
+import * as HttpStatus from "effect/http/HttpStatus";
+
+export function isRateLimited(status: number) {
+	return status === HttpStatus.fromLiteral("TooManyRequests");
+}
+
+export function isEmpty(status: number) {
+	return status === HttpStatus.fromLiteral("NoContent");
+}

package/src/adapters/routeKey.ts

@@ -0,0 +1,15 @@
+export function routeKey(method: string, path: string) {
+	const parts = path.split("?")[0]?.split("/") ?? [];
+	let major = "";
+	if (parts[1] === "channels" || parts[1] === "guilds") {
+		major = parts[2] ?? "";
+	}
+	if (parts[1] === "webhooks") {
+		major = `${parts[2]}/${parts[3]}`;
+	}
+	const normalized = parts.map((part, index) => (/^\d+$/u.test(part) && index !== 2 ? ":id" : part));
+	if (parts[1] === "channels" || parts[1] === "guilds" || parts[1] === "webhooks") {
+		normalized[2] = ":major";
+	}
+	return { major, route: `${method} ${normalized.join("/")}` };
+}

package/src/adapters/webSocketLayer.ts

@@ -0,0 +1,7 @@
+import { Effect, Layer } from "effect";
+import { Socket } from "effect/socket";
+import { GatewayTransport } from "#GatewayTransport.ts";
+
+export const webSocketLayer = Layer.succeed(GatewayTransport)({
+	open: (url) => Socket.makeWebSocket(url).pipe(Effect.provide(Socket.layerWebSocketConstructorGlobal)),
+});

package/src/errors.ts

@@ -0,0 +1,13 @@
+import { Schema } from "effect";
+
+export class DiscordTransportError extends Schema.TaggedError<DiscordTransportError>()("DiscordTransportError", {}) {}
+
+export class DiscordRateLimited extends Schema.TaggedError<DiscordRateLimited>()("DiscordRateLimited", {
+	retryAfter: Schema.Number,
+}) {}
+
+export class DiscordGatewayClosed extends Schema.TaggedError<DiscordGatewayClosed>()("DiscordGatewayClosed", {
+	code: Schema.Number,
+}) {}
+
+export class DiscordGatewayProtocolError extends Schema.TaggedError<DiscordGatewayProtocolError>()("DiscordGatewayProtocolError", {}) {}

package/src/gatewayConnection.ts

@@ -0,0 +1,89 @@
+import { Deferred, Effect, Redacted, Schema } from "effect";
+import { Socket } from "effect/socket";
+import { DiscordConfig } from "#DiscordConfig.ts";
+import { DiscordToken } from "#DiscordToken.ts";
+import { decodeData, decodeFrame, type GatewayDispatch, type GatewayFrame, type GatewaySession, Hello, Ready, reconnect } from "#gatewayProtocol.ts";
+
+export function gatewayConnection(session: GatewaySession, dispatch: (event: GatewayDispatch) => Effect.Effect<void>) {
+	return Effect.gen(function* () {
+		const socket = yield* Socket.Socket;
+		const token = yield* DiscordToken;
+		const { intents } = yield* DiscordConfig;
+		const reader = yield* socket.reader;
+		const writer = yield* socket.writer;
+		const failed = yield* Deferred.make<never, Socket.SocketError>();
+		let acknowledged = true;
+		const send = Effect.fnUntraced(function* (op: number, d: unknown) {
+			const frame = yield* Schema.encodeEffect(Schema.fromJsonString(Schema.Unknown))({ d, op }).pipe(Effect.orDie);
+			yield* writer.write(frame);
+		});
+		const startHeartbeat = Effect.fnUntraced(function* (interval: number) {
+			const pulse = Effect.gen(function* () {
+				while (true) {
+					yield* Effect.sleep(interval);
+					if (!acknowledged) {
+						return yield* reconnect();
+					}
+					acknowledged = false;
+					yield* send(1, session.sequence);
+				}
+			});
+			yield* pulse.pipe(
+				Effect.catch((error) => Deferred.fail(failed, error)),
+				Effect.forkScoped,
+			);
+		});
+		const hello = Effect.fnUntraced(function* (data: unknown) {
+			const { heartbeatInterval } = yield* decodeData(Hello, data);
+			const payload =
+				session.sessionId === undefined
+					? { intents, properties: { browser: "platform", device: "platform", os: "linux" }, token: Redacted.value(token) }
+					: { seq: session.sequence, "session_id": session.sessionId, token: Redacted.value(token) };
+			yield* send(session.sessionId === undefined ? 2 : 6, payload);
+			yield* startHeartbeat(heartbeatInterval);
+		});
+		const deliver = Effect.fnUntraced(function* (frame: GatewayFrame) {
+			if (frame.t === "READY") {
+				const ready = yield* decodeData(Ready, frame.d);
+				session.sessionId = ready.sessionId;
+				session.resumeUrl = ready.resumeUrl;
+			}
+			if (frame.t !== undefined && frame.t !== null && frame.s !== undefined && frame.s !== null) {
+				yield* dispatch({ data: frame.d, sequence: frame.s, type: frame.t });
+			}
+		});
+		const handle = Effect.fnUntraced(function* (frame: GatewayFrame) {
+			if (frame.s !== undefined && frame.s !== null) {
+				session.sequence = frame.s;
+			}
+			switch (frame.op) {
+				case 10:
+					return yield* hello(frame.d);
+				case 11:
+					acknowledged = true;
+					return;
+				case 1:
+					return yield* send(1, session.sequence);
+				case 7:
+					return yield* reconnect();
+				case 9:
+					if (frame.d !== true) {
+						session.sessionId = undefined;
+						session.resumeUrl = undefined;
+						session.sequence = null;
+					}
+					return yield* reconnect();
+				case 0:
+					return yield* deliver(frame);
+			}
+		});
+		const consume = Effect.gen(function* () {
+			while (true) {
+				for (const raw of yield* reader.pull) {
+					yield* handle(yield* decodeFrame(raw));
+				}
+			}
+		});
+		return yield* Effect.raceFirst(consume, Deferred.await(failed));
+	}).pipe(Effect.scoped);
+}

package/src/gatewayProtocol.ts

@@ -0,0 +1,42 @@
+import { Effect, Schema } from "effect";
+import { Socket } from "effect/socket";
+import { DiscordGatewayProtocolError } from "#errors.ts";
+
+export const GatewayFrame = Schema.Struct({
+	d: Schema.Unknown,
+	op: Schema.Number,
+	s: Schema.optional(Schema.NullOr(Schema.Number)),
+	t: Schema.optional(Schema.NullOr(Schema.String)),
+});
+export type GatewayFrame = typeof GatewayFrame.Type;
+
+export interface GatewayDispatch {
+	readonly data: unknown;
+	readonly sequence: number;
+	readonly type: string;
+}
+
+export interface GatewaySession {
+	resumeUrl: string | undefined;
+	sequence: number | null;
+	sessionId: string | undefined;
+}
+
+export function decodeFrame(frame: string | Uint8Array) {
+	return Schema.decodeUnknownEffect(Schema.fromJsonString(GatewayFrame))(typeof frame === "string" ? frame : new TextDecoder().decode(frame)).pipe(
+		Effect.mapError(() => new DiscordGatewayProtocolError({})),
+	);
+}
+
+export const Hello = Schema.Struct({ heartbeatInterval: Schema.Number }).pipe(Schema.encodeKeys({ heartbeatInterval: "heartbeat_interval" }));
+export const Ready = Schema.Struct({ resumeUrl: Schema.String, sessionId: Schema.String }).pipe(
+	Schema.encodeKeys({ resumeUrl: "resume_gateway_url", sessionId: "session_id" }),
+);
+
+export function decodeData<TSchema extends Schema.ConstraintDecoder<unknown>>(schema: TSchema, data: unknown) {
+	return Schema.decodeUnknownEffect(schema)(data).pipe(Effect.mapError(() => new DiscordGatewayProtocolError({})));
+}
+
+export function reconnect() {
+	return Effect.fail(new Socket.SocketError({ reason: new Socket.SocketCloseError({ code: 4000 }) }));
+}

package/src/rateLimits.ts

@@ -0,0 +1,39 @@
+import { Clock, Effect } from "effect";
+import type { Headers } from "effect/http";
+
+export function rateLimits() {
+	const routes = new Map<string, string>();
+	const blocked = new Map<string, number>();
+	let globalReset = 0;
+	function key(route: string, major: string) {
+		return `${routes.get(route) ?? route}:${major}`;
+	}
+	return {
+		observe: (route: string, major: string, headers: Headers.Headers) =>
+			Effect.gen(function* () {
+				const bucket = headers["x-ratelimit-bucket"];
+				if (bucket !== undefined) {
+					routes.set(route, bucket);
+				}
+				if (headers["x-ratelimit-remaining"] === "0") {
+					blocked.set(key(route, major), (yield* Clock.currentTimeMillis) + Number(headers["x-ratelimit-reset-after"] ?? 0) * 1000);
+				}
+			}),
+		refuse: (route: string, major: string, seconds: number, global: boolean) =>
+			Effect.gen(function* () {
+				const reset = (yield* Clock.currentTimeMillis) + seconds * 1000;
+				if (global) {
+					globalReset = Math.max(globalReset, reset);
+				} else {
+					blocked.set(key(route, major), reset);
+				}
+			}),
+		wait: (route: string, major: string) =>
+			Effect.gen(function* () {
+				const delay = Math.max(globalReset, blocked.get(key(route, major)) ?? 0) - (yield* Clock.currentTimeMillis);
+				if (delay > 0) {
+					yield* Effect.sleep(delay);
+				}
+			}),
+	};
+}

package/src/request.ts

@@ -0,0 +1,7 @@
+import { Effect, Schema } from "effect";
+import type { HttpMethod } from "effect/http/HttpMethod";
+import { DiscordRest } from "#DiscordRest.ts";
+
+export function request<TSchema extends Schema.ConstraintDecoder<unknown>>(method: HttpMethod, path: string, schema: TSchema, body?: unknown) {
+	return Effect.flatMap(DiscordRest, (rest) => rest.request(method, path, body)).pipe(Effect.flatMap(Schema.decodeUnknownEffect(schema)));
+}

package/src/restClient.ts

@@ -0,0 +1,64 @@
+import { Effect, Redacted, Schema, Semaphore } from "effect";
+import { HttpClient, HttpClientRequest } from "effect/http";
+import type { HttpMethod } from "effect/http/HttpMethod";
+import { readBoundedJson } from "@shivaedev/http/body.ts";
+import { checkStatus } from "@shivaedev/http/checkStatus.ts";
+import { isEmpty, isRateLimited } from "#adapters/restStatus.ts";
+import { routeKey } from "#adapters/routeKey.ts";
+import { DiscordConfig } from "#DiscordConfig.ts";
+import { DiscordToken } from "#DiscordToken.ts";
+import { DiscordRateLimited, DiscordTransportError } from "#errors.ts";
+import { rateLimits } from "#rateLimits.ts";
+
+const Limited = Schema.Struct({ global: Schema.optional(Schema.Boolean), retryAfter: Schema.Number }).pipe(
+	Schema.encodeKeys({ retryAfter: "retry_after" }),
+);
+
+export const initializeRest = Effect.gen(function* () {
+	const client = HttpClient.withScope(yield* HttpClient.HttpClient);
+	const token = yield* DiscordToken;
+	const config = yield* DiscordConfig;
+	const rates = rateLimits();
+	const lock = yield* Semaphore.make(1);
+	const request = Effect.fnUntraced(function* (method: HttpMethod, path: string, body?: unknown) {
+		const { major, route } = routeKey(method, path);
+		let input = HttpClientRequest.make(method)(`${config.apiUrl}${path}`).pipe(
+			HttpClientRequest.setHeader("Authorization", `Bot ${Redacted.value(token)}`),
+		);
+		if (body !== undefined) {
+			input = yield* HttpClientRequest.bodyJson(input, body);
+		}
+		for (let attempt = 0; ; attempt += 1) {
+			yield* rates.wait(route, major);
+			const answer = yield* Effect.scoped(
+				Effect.gen(function* () {
+					const response = yield* client.execute(input);
+					yield* rates.observe(route, major, response.headers);
+					if (isRateLimited(response.status)) {
+						const limit = yield* readBoundedJson(response, 64 * 1024, Limited);
+						yield* rates.refuse(route, major, limit.retryAfter, limit.global === true);
+						if (attempt === 3) {
+							return yield* new DiscordRateLimited({ retryAfter: limit.retryAfter });
+						}
+						return { retry: true, value: undefined };
+					}
+					yield* checkStatus(response);
+					const value = isEmpty(response.status) ? undefined : yield* readBoundedJson(response, 1024 * 1024, Schema.Unknown);
+					return { retry: false, value };
+				}),
+			);
+			if (!answer.retry) {
+				return answer.value;
+			}
+		}
+	});
+	return { lock, request };
+});
+
+export function restRequest(state: Effect.Success<typeof initializeRest>) {
+	return (method: HttpMethod, path: string, body?: unknown) =>
+		state.request(method, path, body).pipe(
+			state.lock.withPermit,
+			Effect.catchTag("HttpClientError", () => Effect.fail(new DiscordTransportError({}))),
+		);
+}

package/src/runGateway.ts

@@ -0,0 +1,32 @@
+import { Effect } from "effect";
+import { Socket } from "effect/socket";
+import { DiscordConfig } from "#DiscordConfig.ts";
+import { DiscordGatewayClosed } from "#errors.ts";
+import { GatewayTransport } from "#GatewayTransport.ts";
+import { gatewayConnection } from "#gatewayConnection.ts";
+import type { GatewayDispatch, GatewaySession } from "#gatewayProtocol.ts";
+
+export const runGateway = Effect.fnUntraced(function* (dispatch: (event: GatewayDispatch) => Effect.Effect<void>) {
+	const config = yield* DiscordConfig;
+	const transport = yield* GatewayTransport;
+	const session: GatewaySession = { resumeUrl: undefined, sequence: null, sessionId: undefined };
+	while (true) {
+		const socket = yield* transport.open(`${session.resumeUrl ?? config.gatewayUrl}/?v=10&encoding=json`);
+		yield* gatewayConnection(session, dispatch)
+			.pipe(Effect.provideService(Socket.Socket, socket))
+			.pipe(
+				Effect.catchTag("SocketError", (error) => {
+					const code = error.reason._tag === "SocketCloseError" ? error.reason.code : undefined;
+					if (code === 4004 || (code !== undefined && code >= 4010 && code <= 4014)) {
+						return Effect.fail(new DiscordGatewayClosed({ code }));
+					}
+					if (code === 4007 || code === 4009) {
+						session.sessionId = undefined;
+						session.resumeUrl = undefined;
+						session.sequence = null;
+					}
+					return Effect.sleep("1 second");
+				}),
+			);
+	}
+});