@yydb/redis 0.0.1 → 0.0.2

package/bin/redis-cli.mjs

@@ -0,0 +1,192 @@
+#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import { createConnection } from "node:net";
+
+const { version } = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+const maxRequestBytes = 1024 * 1024;
+const maxReplyBytes = 8 * 1024 * 1024;
+
+function parseValue(buffer, offset = 0, depth = 0) {
+    if (depth > 32) throw new Error("RESP response exceeds nesting limit");
+    if (offset >= buffer.length) return null;
+    const marker = buffer[offset];
+    const lineEnd = buffer.indexOf("\r\n", offset + 1);
+    if (lineEnd < 0) return null;
+    const line = buffer.toString("utf8", offset + 1, lineEnd);
+    const next = lineEnd + 2;
+    if (marker === 43 || marker === 45)
+        return { value: { kind: marker === 43 ? "string" : "error", value: line }, next };
+    if (marker === 58) {
+        if (!/^-?\d+$/.test(line)) throw new Error("invalid RESP integer response");
+        const integer = BigInt(line);
+        if (integer < -(1n << 63n) || integer >= 1n << 63n)
+            throw new Error("RESP integer outside signed 64-bit range");
+        return { value: { kind: "integer", value: line }, next };
+    }
+    if (marker === 36) {
+        if (!/^(?:-1|\d+)$/.test(line)) throw new Error("invalid RESP bulk length");
+        const length = Number(line);
+        if (!Number.isSafeInteger(length) || length < -1)
+            throw new Error("invalid RESP bulk length");
+        if (length === -1) return { value: { kind: "null" }, next };
+        if (length > maxReplyBytes) throw new Error("RESP bulk reply exceeds byte limit");
+        const end = next + length;
+        if (buffer.length < end + 2) return null;
+        if (buffer[end] !== 13 || buffer[end + 1] !== 10)
+            throw new Error("invalid RESP bulk terminator");
+        return { value: { kind: "bulk", value: buffer.subarray(next, end) }, next: end + 2 };
+    }
+    if (marker === 42) {
+        if (!/^(?:-1|\d+)$/.test(line)) throw new Error("invalid RESP array length");
+        const count = Number(line);
+        if (!Number.isSafeInteger(count) || count < -1 || count > 1024)
+            throw new Error("invalid RESP array length");
+        if (count === -1) return { value: { kind: "null" }, next };
+        const values = [];
+        let cursor = next;
+        for (let index = 0; index < count; index += 1) {
+            const parsed = parseValue(buffer, cursor, depth + 1);
+            if (parsed === null) return null;
+            values.push(parsed.value);
+            cursor = parsed.next;
+        }
+        return { value: { kind: "array", value: values }, next: cursor };
+    }
+    throw new Error("unsupported RESP2 response type");
+}
+
+function encodeCommand(args) {
+    const values = args.map((value) => Buffer.from(value, "utf8"));
+    const encoded = Buffer.concat([
+        Buffer.from(`*${values.length}\r\n`),
+        ...values.flatMap((value) => [
+            Buffer.from(`$${value.length}\r\n`),
+            value,
+            Buffer.from("\r\n"),
+        ]),
+    ]);
+    if (encoded.length > maxRequestBytes) throw new Error("Redis command exceeds byte limit");
+    return encoded;
+}
+
+function writeValue(value, raw) {
+    if (value.kind === "error") throw new Error(value.value);
+    if (value.kind === "null") {
+        process.stdout.write("(nil)\n");
+        return;
+    }
+    if (value.kind === "array") {
+        for (const item of value.value) writeValue(item, raw);
+        return;
+    }
+    if (value.kind === "bulk") {
+        process.stdout.write(raw ? value.value : value.value.toString("utf8"));
+        process.stdout.write("\n");
+        return;
+    }
+    process.stdout.write(`${value.value}\n`);
+}
+
+function parseArguments(args) {
+    const options = { host: "127.0.0.1", port: 6379, database: 0, raw: false };
+    const command = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (command.length > 0) {
+            command.push(arg);
+            continue;
+        }
+        if (arg === "--raw") options.raw = true;
+        else if (["-h", "--host", "-p", "--port", "-n", "--db"].includes(arg)) {
+            const value = args[++index];
+            if (value === undefined) throw new Error(`missing value for ${arg}`);
+            if (arg === "-h" || arg === "--host") options.host = value;
+            else {
+                const parsed = Number(value);
+                const minimum = arg === "-n" || arg === "--db" ? 0 : 1;
+                if (
+                    !Number.isInteger(parsed) ||
+                    parsed < minimum ||
+                    parsed > (arg === "-n" || arg === "--db" ? 15 : 65535)
+                ) {
+                    throw new Error(`invalid value for ${arg}`);
+                }
+                if (arg === "-p" || arg === "--port") options.port = parsed;
+                else options.database = parsed;
+            }
+        } else if (arg.startsWith("-")) throw new Error(`unsupported option '${arg}'`);
+        else command.push(arg);
+    }
+    if (command.length === 0) command.push("PING");
+    return { options, command };
+}
+
+function exchange(options, commands) {
+    return new Promise((resolve, reject) => {
+        const socket = createConnection({ host: options.host, port: options.port });
+        let pending = Buffer.alloc(0);
+        let commandIndex = 0;
+        let settled = false;
+        let timer;
+        const allCommands =
+            options.database === 0 ? [commands] : [["SELECT", String(options.database)], commands];
+        const finish = (error, value) => {
+            if (settled) return;
+            settled = true;
+            clearTimeout(timer);
+            socket.destroy();
+            if (error) reject(error);
+            else resolve(value);
+        };
+        timer = setTimeout(() => finish(new Error("Redis connection timed out")), 5000);
+        socket.on("connect", () => {
+            try {
+                socket.write(encodeCommand(allCommands[commandIndex]));
+            } catch (error) {
+                finish(error);
+            }
+        });
+        socket.on("data", (chunk) => {
+            try {
+                pending = Buffer.concat([pending, chunk]);
+                if (pending.length > maxReplyBytes)
+                    throw new Error("RESP reply exceeds byte limit");
+                const parsed = parseValue(pending);
+                if (parsed === null) return;
+                pending = pending.subarray(parsed.next);
+                if (commandIndex === 0 && options.database !== 0) {
+                    if (parsed.value.kind === "error") throw new Error(parsed.value.value);
+                    if (parsed.value.kind !== "string" || parsed.value.value !== "OK") {
+                        throw new Error("Redis SELECT did not return OK");
+                    }
+                    commandIndex += 1;
+                    socket.write(encodeCommand(allCommands[commandIndex]));
+                    return;
+                }
+                finish(null, parsed.value);
+            } catch (error) {
+                finish(error);
+            }
+        });
+        socket.on("error", (error) => finish(error));
+        socket.on("end", () => finish(new Error("Redis closed before a complete reply")));
+    });
+}
+
+async function main(args) {
+    if (args.length === 1 && ["--version", "-V"].includes(args[0])) {
+        console.log(`redis-cli ${version} (YYDS RESP2 client)`);
+        return;
+    }
+    if (args.length === 1 && args[0] === "--help") {
+        console.log("Usage: redis-cli [-h HOST] [-p PORT] [-n DB] [--raw] [COMMAND [ARG ...]]");
+        return;
+    }
+    const { options, command } = parseArguments(args);
+    writeValue(await exchange(options, command), options.raw);
+}
+
+main(process.argv.slice(2)).catch((error) => {
+    console.error(`@yydb/redis: ${error.message}`);
+    process.exitCode = 1;
+});

package/bin/redis-server.mjs

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import { launchYydsServer } from "@yydb/yyds/node/cluster";
+
+const args = process.argv.slice(2);
+if (args.length === 1 && args[0] === "--help") {
+    console.log("Usage: redis-server --data-dir DIR --cluster-id ID --node-id ID [--port PORT]");
+    console.log("Starts the YYDS node and its protocol listener through the yyds cluster tool.");
+} else {
+    launchYydsServer("redis", args)
+        .then((code) => {
+            process.exitCode = code;
+        })
+        .catch((error) => {
+            console.error("@yydb/redis: " + error.message);
+            process.exitCode = 127;
+        });
+}

package/package.json

@@ -1,34 +1,60 @@
 {
   "name": "@yydb/redis",
-  "version": "0.0.1",
-  "description": "Redis driver and workbench surfaces for SQL Studio — 0.0.1 Developer Preview",
-  "type": "module",
+  "version": "0.0.2",
+  "description": "Pretend you installed Redis. YYDS scripting runtime underneath.",
   "license": "MPL-2.0",
+  "type": "module",
   "sideEffects": false,
-  "main": "./src/index.ts",
-  "types": "./src/index.ts",
   "exports": {
     ".": {
       "types": "./src/index.ts",
       "import": "./src/index.ts",
       "default": "./src/index.ts"
+    },
+    "./node": {
+      "types": "./src/node.ts",
+      "import": "./src/node.ts",
+      "default": "./src/node.ts"
     }
   },
+  "bin": {
+    "redis-server": "./bin/redis-server.mjs",
+    "redis-cli": "./bin/redis-cli.mjs"
+  },
   "files": [
+    "bin",
     "src",
-    "README.md"
+    "readme.md"
   ],
   "scripts": {
-    "typecheck": "tsc --noEmit -p tsconfig.json"
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "test": "node --experimental-strip-types --test \"./tests/**/*.test.ts\""
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yy-database/yyds.git",
+    "directory": "projects/packages/redis"
+  },
+  "homepage": "https://github.com/yy-database/yyds/tree/dev/projects/packages/redis#readme",
+  "bugs": {
+    "url": "https://github.com/yy-database/yyds/issues"
+  },
+  "keywords": [
+    "yyds",
+    "redis",
+    "disguise"
+  ],
+  "publishConfig": {
+    "access": "public"
   },
   "dependencies": {
-    "@yydb/sql-studio-protocol": "0.0.1"
+    "@yydb/yyds": "0.0.2"
   },
   "devDependencies": {
+    "@types/node": "^22.15.0",
     "typescript": "^5.9.2"
   },
-  "publishConfig": {
-    "access": "public",
-    "tag": "dev"
+  "engines": {
+    "node": ">=18"
   }
 }

package/readme.md

@@ -0,0 +1,26 @@
+# @yyds/redis
+
+`redis-cli` is a RESP2 client for a running YYDS Redis protocol service. The service lifecycle belongs to the `yyds` tool, which starts the node and its protocol listener.
+
+```bash
+redis-cli PING
+# PONG
+
+redis-cli -h 127.0.0.1 -p 6379 SET key value
+redis-cli -h 127.0.0.1 -p 6379 SET key value NX
+redis-cli -h 127.0.0.1 -p 6379 SET key replacement XX
+redis-cli -h 127.0.0.1 -p 6379 EXISTS key
+redis-cli -h 127.0.0.1 -p 6379 GETDEL key
+redis-cli -h 127.0.0.1 -p 6379 GETSET key replacement
+redis-cli -h 127.0.0.1 -p 6379 INCR visits
+redis-cli -h 127.0.0.1 -p 6379 INCRBY visits -2
+redis-cli -h 127.0.0.1 -p 6379 DECRBY visits 2
+redis-cli -h 127.0.0.1 -p 6379 MGET key missing key
+redis-cli -n 1 GET key
+```
+
+The node-owned service supports binary `GET`, ordered atomic `MGET`, single-key `EXISTS`, atomic `GETDEL` and `GETSET`, `SET`, `SET ... NX` and `SET ... XX`, single-key `DEL`, and signed 64-bit `INCR`/`INCRBY`/`DECR`/`DECRBY`. MGET preserves request order and duplicate keys. Conditional set, get-and-delete, get-and-replace, increments/decrements and MGET are atomic within the current single-process executor and persisted by its mounted shard. Missing integer keys start at zero. Multi-key `EXISTS` and other `SET` options remain unsupported. These operations do not imply replicated or multi-node atomicity. The client supports one RESP2 command per invocation, host/port/database selection, simple strings, errors, integers, bulk values and arrays. It does not provide authentication, TLS, RESP3, interactive mode or full `redis-cli` compatibility. Server lifecycle is provided by `yyds`, not a second `redis-server` manager.
+
+`redis-server` delegates to the `yyds` executable and holds the node lifecycle. Pass `--data-dir`, `--cluster-id`, and `--node-id`; set `YYDS_CLI_PATH` when the executable is not on `PATH`. The alias does not create a Redis-only supervisor.
+
+The package API re-exports `@yyds/yyds` unchanged.

package/src/disguise.ts

@@ -0,0 +1,23 @@
+import { loadYydsNative } from "@yydb/yyds/node";
+
+export type DisguiseRuntime = {
+    product: string;
+    yydsVersion: string;
+    ping: string;
+};
+
+export function loadDisguiseRuntime(product: string): DisguiseRuntime {
+    try {
+        const native = loadYydsNative();
+        return {
+            product,
+            yydsVersion: native.yydsVersion(),
+            ping: native.ping(),
+        };
+    } catch (error) {
+        throw new Error(
+            `@yydb/${product}: native runtime missing. Install @yydb/yyds and run pnpm build:napi`,
+            { cause: error },
+        );
+    }
+}

package/src/index.ts

@@ -1,21 +1 @@
-/**
- * `@yydb/redis` — Redis driver for SQL Studio (Key Browser / Command Console).
- * Product brand is SQL Studio; Redis is a Data Source, not a SQL engine.
- */
-
-import type { StudioDriverRegistration } from "@yydb/sql-studio-protocol";
-
-export const DRIVER_ID = "redis" as const;
-
-export type RedisFactoryOptions = {
-    id: string;
-    url: string;
-};
-
-export function redis(options: RedisFactoryOptions): StudioDriverRegistration {
-    return {
-        id: options.id,
-        kind: "redis",
-        driver: { url: options.url, kind: DRIVER_ID },
-    };
-}
+export * from "@yydb/yyds";

package/src/node.ts

@@ -0,0 +1 @@
+export * from "@yydb/yyds/node";

package/README.md

@@ -1,4 +0,0 @@
-# 🔴 `@yydb/redis`
-
-Redis driver under the **SQL Studio** brand. Studio UI uses Key Browser /
-Command Console for this Data Source.