@ekodb/ekodb-client 0.17.0 → 0.18.0

package/dist/functions.test.js

@@ -195,6 +195,90 @@ const functions_1 = require("./functions");
     });
 });
 // ============================================================================
+// JWT primitives: JwtSign, JwtVerify (ekoDB >= 0.42.0)
+// ============================================================================
+(0, vitest_1.describe)("Stage.jwtSign", () => {
+    (0, vitest_1.it)("produces a JwtSign stage with claims, expiry, and algorithm", () => {
+        const stage = functions_1.Stage.jwtSign({ sub: "{{user_id}}", role: "admin" }, "{{env.JWT_SECRET}}", "token", 3600, "HS256");
+        (0, vitest_1.expect)(stage.type).toBe("JwtSign");
+        (0, vitest_1.expect)(stage.claims).toEqual({ sub: "{{user_id}}", role: "admin" });
+        (0, vitest_1.expect)(stage.secret).toBe("{{env.JWT_SECRET}}");
+        (0, vitest_1.expect)(stage.expires_in_secs).toBe(3600);
+        (0, vitest_1.expect)(stage.algorithm).toBe("HS256");
+        (0, vitest_1.expect)(stage.output_field).toBe("token");
+    });
+    (0, vitest_1.it)("leaves algorithm and expires_in_secs undefined when omitted", () => {
+        const stage = functions_1.Stage.jwtSign({ sub: "u" }, "{{env.JWT_SECRET}}", "t");
+        (0, vitest_1.expect)(stage.algorithm).toBeUndefined();
+        (0, vitest_1.expect)(stage.expires_in_secs).toBeUndefined();
+    });
+});
+(0, vitest_1.describe)("Stage.jwtVerify", () => {
+    (0, vitest_1.it)("produces a JwtVerify stage wiring token_field and output_field", () => {
+        const stage = functions_1.Stage.jwtVerify("auth_token", "{{env.JWT_SECRET}}", "claims", "HS512");
+        (0, vitest_1.expect)(stage.type).toBe("JwtVerify");
+        (0, vitest_1.expect)(stage.token_field).toBe("auth_token");
+        (0, vitest_1.expect)(stage.secret).toBe("{{env.JWT_SECRET}}");
+        (0, vitest_1.expect)(stage.algorithm).toBe("HS512");
+        (0, vitest_1.expect)(stage.output_field).toBe("claims");
+    });
+});
+(0, vitest_1.describe)("JWT stages JSON wire format", () => {
+    (0, vitest_1.it)("JwtSign round-trips through JSON unchanged", () => {
+        const stage = functions_1.Stage.jwtSign({ sub: "user-1" }, "{{env.JWT_SECRET}}", "token", 3600, "HS256");
+        const wire = JSON.parse(JSON.stringify(stage));
+        (0, vitest_1.expect)(wire).toEqual({
+            type: "JwtSign",
+            claims: { sub: "user-1" },
+            secret: "{{env.JWT_SECRET}}",
+            algorithm: "HS256",
+            expires_in_secs: 3600,
+            output_field: "token",
+        });
+    });
+    (0, vitest_1.it)("JwtVerify round-trips through JSON unchanged", () => {
+        const stage = functions_1.Stage.jwtVerify("token", "{{env.JWT_SECRET}}", "claims", "HS256");
+        const wire = JSON.parse(JSON.stringify(stage));
+        (0, vitest_1.expect)(wire).toEqual({
+            type: "JwtVerify",
+            token_field: "token",
+            secret: "{{env.JWT_SECRET}}",
+            algorithm: "HS256",
+            output_field: "claims",
+        });
+    });
+});
+// ============================================================================
+// EmailSend (ekoDB >= 0.42.0)
+// ============================================================================
+(0, vitest_1.describe)("Stage.emailSend", () => {
+    (0, vitest_1.it)("produces a SendGrid EmailSend stage with full payload", () => {
+        const stage = functions_1.Stage.emailSend("alice@example.com", "Welcome", "<p>Hi Alice</p>", "bot@example.com", "{{env.SENDGRID_API_KEY}}", {
+            reply_to: "support@example.com",
+            provider: "sendgrid",
+            html: true,
+            output_field: "send_result",
+        });
+        (0, vitest_1.expect)(stage.type).toBe("EmailSend");
+        (0, vitest_1.expect)(stage.to).toBe("alice@example.com");
+        (0, vitest_1.expect)(stage.subject).toBe("Welcome");
+        (0, vitest_1.expect)(stage.body).toBe("<p>Hi Alice</p>");
+        (0, vitest_1.expect)(stage.from).toBe("bot@example.com");
+        (0, vitest_1.expect)(stage.reply_to).toBe("support@example.com");
+        (0, vitest_1.expect)(stage.api_key).toBe("{{env.SENDGRID_API_KEY}}");
+        (0, vitest_1.expect)(stage.provider).toBe("sendgrid");
+        (0, vitest_1.expect)(stage.html).toBe(true);
+        (0, vitest_1.expect)(stage.output_field).toBe("send_result");
+    });
+    (0, vitest_1.it)("leaves optional fields undefined when omitted", () => {
+        const stage = functions_1.Stage.emailSend("x@example.com", "s", "b", "f@example.com", "k");
+        (0, vitest_1.expect)(stage.reply_to).toBeUndefined();
+        (0, vitest_1.expect)(stage.provider).toBeUndefined();
+        (0, vitest_1.expect)(stage.html).toBeUndefined();
+        (0, vitest_1.expect)(stage.output_field).toBeUndefined();
+    });
+});
+// ============================================================================
 // Error Handling & Control Flow: TryCatch, Parallel, Sleep (ekoDB >= 0.42.0)
 // ============================================================================
 (0, vitest_1.describe)("Stage.tryCatch", () => {
@@ -325,3 +409,134 @@ const functions_1 = require("./functions");
         });
     });
 });
+(0, vitest_1.describe)("Crypto and concurrency stages", () => {
+    (0, vitest_1.it)("hmacSign builds a stage with explicit algorithm and encoding", () => {
+        const s = functions_1.Stage.hmacSign("{{payload}}", "{{env.KEY}}", "mac", {
+            algorithm: "sha256",
+            encoding: "hex",
+        });
+        (0, vitest_1.expect)(s).toEqual({
+            type: "HmacSign",
+            input: "{{payload}}",
+            secret: "{{env.KEY}}",
+            algorithm: "sha256",
+            output_field: "mac",
+            encoding: "hex",
+        });
+    });
+    (0, vitest_1.it)("hmacVerify wires all fields", () => {
+        const s = functions_1.Stage.hmacVerify("{{p}}", "{{m}}", "{{env.K}}", "ok");
+        (0, vitest_1.expect)(s).toMatchObject({
+            type: "HmacVerify",
+            input: "{{p}}",
+            provided_mac: "{{m}}",
+            secret: "{{env.K}}",
+            output_field: "ok",
+        });
+    });
+    (0, vitest_1.it)("aesEncrypt and aesDecrypt build matching envelope contracts", () => {
+        const enc = functions_1.Stage.aesEncrypt("{{plain}}", "{{env.DATA_KEY}}", "envelope", "hex");
+        (0, vitest_1.expect)(enc).toMatchObject({
+            type: "AesEncrypt",
+            plaintext: "{{plain}}",
+            key: "{{env.DATA_KEY}}",
+            key_encoding: "hex",
+            output_field: "envelope",
+        });
+        const dec = functions_1.Stage.aesDecrypt("envelope", "{{env.DATA_KEY}}", "plain", "hex");
+        (0, vitest_1.expect)(dec).toMatchObject({
+            type: "AesDecrypt",
+            ciphertext_field: "envelope",
+            output_field: "plain",
+        });
+    });
+    (0, vitest_1.it)("uuidGenerate is a single-field stage", () => {
+        (0, vitest_1.expect)(functions_1.Stage.uuidGenerate("id")).toEqual({
+            type: "UuidGenerate",
+            output_field: "id",
+        });
+    });
+    (0, vitest_1.it)("totpGenerate and totpVerify build with all options", () => {
+        const gen = functions_1.Stage.totpGenerate("{{env.TOTP}}", "code", {
+            digits: 6,
+            period: 30,
+            algorithm: "sha1",
+        });
+        (0, vitest_1.expect)(gen.type).toBe("TotpGenerate");
+        const ver = functions_1.Stage.totpVerify("{{user_code}}", "{{env.TOTP}}", "ok", {
+            skew: 1,
+        });
+        (0, vitest_1.expect)(ver.type).toBe("TotpVerify");
+    });
+    (0, vitest_1.it)("base64Encode/Decode and hexEncode/Decode build correctly", () => {
+        (0, vitest_1.expect)(functions_1.Stage.base64Encode("{{x}}", "b", true)).toMatchObject({
+            type: "Base64Encode",
+            url_safe: true,
+        });
+        (0, vitest_1.expect)(functions_1.Stage.base64Decode("{{b}}", "x")).toMatchObject({
+            type: "Base64Decode",
+        });
+        (0, vitest_1.expect)(functions_1.Stage.hexEncode("{{x}}", "h")).toEqual({
+            type: "HexEncode",
+            input: "{{x}}",
+            output_field: "h",
+        });
+        (0, vitest_1.expect)(functions_1.Stage.hexDecode("{{h}}", "x")).toEqual({
+            type: "HexDecode",
+            input: "{{h}}",
+            output_field: "x",
+        });
+    });
+    (0, vitest_1.it)("slugify builds a stage", () => {
+        (0, vitest_1.expect)(functions_1.Stage.slugify("{{title}}", "slug")).toEqual({
+            type: "Slugify",
+            input: "{{title}}",
+            output_field: "slug",
+        });
+    });
+    (0, vitest_1.it)("idempotencyClaim, rateLimit, lockAcquire, lockRelease build correctly", () => {
+        (0, vitest_1.expect)(functions_1.Stage.idempotencyClaim("{{ikey}}", 3600, "claim")).toEqual({
+            type: "IdempotencyClaim",
+            key: "{{ikey}}",
+            ttl_secs: 3600,
+            output_field: "claim",
+        });
+        (0, vitest_1.expect)(functions_1.Stage.rateLimit("{{user}}", 100, 60, "rl", "skip")).toMatchObject({
+            type: "RateLimit",
+            limit: 100,
+            window_secs: 60,
+            on_exceed: "skip",
+        });
+        (0, vitest_1.expect)(functions_1.Stage.lockAcquire("{{r}}", 30, "lock")).toEqual({
+            type: "LockAcquire",
+            key: "{{r}}",
+            ttl_secs: 30,
+            output_field: "lock",
+        });
+        (0, vitest_1.expect)(functions_1.Stage.lockRelease("{{r}}", "{{lock.token}}", "rel")).toEqual({
+            type: "LockRelease",
+            key: "{{r}}",
+            token: "{{lock.token}}",
+            output_field: "rel",
+        });
+    });
+    (0, vitest_1.it)("crypto + concurrency stages round-trip through JSON unchanged", () => {
+        const stages = [
+            functions_1.Stage.hmacSign("a", "k", "m", { algorithm: "sha256", encoding: "hex" }),
+            functions_1.Stage.aesEncrypt("p", "k", "e", "hex"),
+            functions_1.Stage.uuidGenerate("id"),
+            functions_1.Stage.totpGenerate("s", "c", {
+                digits: 6,
+                period: 30,
+                algorithm: "sha1",
+            }),
+            functions_1.Stage.idempotencyClaim("k", 60, "f"),
+            functions_1.Stage.rateLimit("k", 5, 60, "rl"),
+            functions_1.Stage.lockAcquire("r", 60, "l"),
+        ];
+        for (const s of stages) {
+            const wire = JSON.parse(JSON.stringify(s));
+            (0, vitest_1.expect)(wire.type).toBe(s.type);
+        }
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ekodb/ekodb-client",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "Official TypeScript/JavaScript client for ekoDB",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/functions.test.ts

@@ -254,6 +254,138 @@ describe("Crypto stages JSON wire format", () => {
   });
 });
 
+// ============================================================================
+// JWT primitives: JwtSign, JwtVerify (ekoDB >= 0.42.0)
+// ============================================================================
+
+describe("Stage.jwtSign", () => {
+  it("produces a JwtSign stage with claims, expiry, and algorithm", () => {
+    const stage = Stage.jwtSign(
+      { sub: "{{user_id}}", role: "admin" },
+      "{{env.JWT_SECRET}}",
+      "token",
+      3600,
+      "HS256",
+    ) as Extract<FunctionStageConfig, { type: "JwtSign" }>;
+    expect(stage.type).toBe("JwtSign");
+    expect(stage.claims).toEqual({ sub: "{{user_id}}", role: "admin" });
+    expect(stage.secret).toBe("{{env.JWT_SECRET}}");
+    expect(stage.expires_in_secs).toBe(3600);
+    expect(stage.algorithm).toBe("HS256");
+    expect(stage.output_field).toBe("token");
+  });
+
+  it("leaves algorithm and expires_in_secs undefined when omitted", () => {
+    const stage = Stage.jwtSign(
+      { sub: "u" },
+      "{{env.JWT_SECRET}}",
+      "t",
+    ) as Extract<FunctionStageConfig, { type: "JwtSign" }>;
+    expect(stage.algorithm).toBeUndefined();
+    expect(stage.expires_in_secs).toBeUndefined();
+  });
+});
+
+describe("Stage.jwtVerify", () => {
+  it("produces a JwtVerify stage wiring token_field and output_field", () => {
+    const stage = Stage.jwtVerify(
+      "auth_token",
+      "{{env.JWT_SECRET}}",
+      "claims",
+      "HS512",
+    ) as Extract<FunctionStageConfig, { type: "JwtVerify" }>;
+    expect(stage.type).toBe("JwtVerify");
+    expect(stage.token_field).toBe("auth_token");
+    expect(stage.secret).toBe("{{env.JWT_SECRET}}");
+    expect(stage.algorithm).toBe("HS512");
+    expect(stage.output_field).toBe("claims");
+  });
+});
+
+describe("JWT stages JSON wire format", () => {
+  it("JwtSign round-trips through JSON unchanged", () => {
+    const stage = Stage.jwtSign(
+      { sub: "user-1" },
+      "{{env.JWT_SECRET}}",
+      "token",
+      3600,
+      "HS256",
+    );
+    const wire = JSON.parse(JSON.stringify(stage));
+    expect(wire).toEqual({
+      type: "JwtSign",
+      claims: { sub: "user-1" },
+      secret: "{{env.JWT_SECRET}}",
+      algorithm: "HS256",
+      expires_in_secs: 3600,
+      output_field: "token",
+    });
+  });
+
+  it("JwtVerify round-trips through JSON unchanged", () => {
+    const stage = Stage.jwtVerify(
+      "token",
+      "{{env.JWT_SECRET}}",
+      "claims",
+      "HS256",
+    );
+    const wire = JSON.parse(JSON.stringify(stage));
+    expect(wire).toEqual({
+      type: "JwtVerify",
+      token_field: "token",
+      secret: "{{env.JWT_SECRET}}",
+      algorithm: "HS256",
+      output_field: "claims",
+    });
+  });
+});
+
+// ============================================================================
+// EmailSend (ekoDB >= 0.42.0)
+// ============================================================================
+
+describe("Stage.emailSend", () => {
+  it("produces a SendGrid EmailSend stage with full payload", () => {
+    const stage = Stage.emailSend(
+      "alice@example.com",
+      "Welcome",
+      "<p>Hi Alice</p>",
+      "bot@example.com",
+      "{{env.SENDGRID_API_KEY}}",
+      {
+        reply_to: "support@example.com",
+        provider: "sendgrid",
+        html: true,
+        output_field: "send_result",
+      },
+    ) as Extract<FunctionStageConfig, { type: "EmailSend" }>;
+    expect(stage.type).toBe("EmailSend");
+    expect(stage.to).toBe("alice@example.com");
+    expect(stage.subject).toBe("Welcome");
+    expect(stage.body).toBe("<p>Hi Alice</p>");
+    expect(stage.from).toBe("bot@example.com");
+    expect(stage.reply_to).toBe("support@example.com");
+    expect(stage.api_key).toBe("{{env.SENDGRID_API_KEY}}");
+    expect(stage.provider).toBe("sendgrid");
+    expect(stage.html).toBe(true);
+    expect(stage.output_field).toBe("send_result");
+  });
+
+  it("leaves optional fields undefined when omitted", () => {
+    const stage = Stage.emailSend(
+      "x@example.com",
+      "s",
+      "b",
+      "f@example.com",
+      "k",
+    ) as Extract<FunctionStageConfig, { type: "EmailSend" }>;
+    expect(stage.reply_to).toBeUndefined();
+    expect(stage.provider).toBeUndefined();
+    expect(stage.html).toBeUndefined();
+    expect(stage.output_field).toBeUndefined();
+  });
+});
+
 // ============================================================================
 // Error Handling & Control Flow: TryCatch, Parallel, Sleep (ekoDB >= 0.42.0)
 // ============================================================================
@@ -442,3 +574,153 @@ describe("New stages JSON wire format", () => {
     });
   });
 });
+
+describe("Crypto and concurrency stages", () => {
+  it("hmacSign builds a stage with explicit algorithm and encoding", () => {
+    const s = Stage.hmacSign("{{payload}}", "{{env.KEY}}", "mac", {
+      algorithm: "sha256",
+      encoding: "hex",
+    });
+    expect(s).toEqual({
+      type: "HmacSign",
+      input: "{{payload}}",
+      secret: "{{env.KEY}}",
+      algorithm: "sha256",
+      output_field: "mac",
+      encoding: "hex",
+    });
+  });
+
+  it("hmacVerify wires all fields", () => {
+    const s = Stage.hmacVerify("{{p}}", "{{m}}", "{{env.K}}", "ok");
+    expect(s).toMatchObject({
+      type: "HmacVerify",
+      input: "{{p}}",
+      provided_mac: "{{m}}",
+      secret: "{{env.K}}",
+      output_field: "ok",
+    });
+  });
+
+  it("aesEncrypt and aesDecrypt build matching envelope contracts", () => {
+    const enc = Stage.aesEncrypt(
+      "{{plain}}",
+      "{{env.DATA_KEY}}",
+      "envelope",
+      "hex",
+    );
+    expect(enc).toMatchObject({
+      type: "AesEncrypt",
+      plaintext: "{{plain}}",
+      key: "{{env.DATA_KEY}}",
+      key_encoding: "hex",
+      output_field: "envelope",
+    });
+    const dec = Stage.aesDecrypt(
+      "envelope",
+      "{{env.DATA_KEY}}",
+      "plain",
+      "hex",
+    );
+    expect(dec).toMatchObject({
+      type: "AesDecrypt",
+      ciphertext_field: "envelope",
+      output_field: "plain",
+    });
+  });
+
+  it("uuidGenerate is a single-field stage", () => {
+    expect(Stage.uuidGenerate("id")).toEqual({
+      type: "UuidGenerate",
+      output_field: "id",
+    });
+  });
+
+  it("totpGenerate and totpVerify build with all options", () => {
+    const gen = Stage.totpGenerate("{{env.TOTP}}", "code", {
+      digits: 6,
+      period: 30,
+      algorithm: "sha1",
+    });
+    expect(gen.type).toBe("TotpGenerate");
+    const ver = Stage.totpVerify("{{user_code}}", "{{env.TOTP}}", "ok", {
+      skew: 1,
+    });
+    expect(ver.type).toBe("TotpVerify");
+  });
+
+  it("base64Encode/Decode and hexEncode/Decode build correctly", () => {
+    expect(Stage.base64Encode("{{x}}", "b", true)).toMatchObject({
+      type: "Base64Encode",
+      url_safe: true,
+    });
+    expect(Stage.base64Decode("{{b}}", "x")).toMatchObject({
+      type: "Base64Decode",
+    });
+    expect(Stage.hexEncode("{{x}}", "h")).toEqual({
+      type: "HexEncode",
+      input: "{{x}}",
+      output_field: "h",
+    });
+    expect(Stage.hexDecode("{{h}}", "x")).toEqual({
+      type: "HexDecode",
+      input: "{{h}}",
+      output_field: "x",
+    });
+  });
+
+  it("slugify builds a stage", () => {
+    expect(Stage.slugify("{{title}}", "slug")).toEqual({
+      type: "Slugify",
+      input: "{{title}}",
+      output_field: "slug",
+    });
+  });
+
+  it("idempotencyClaim, rateLimit, lockAcquire, lockRelease build correctly", () => {
+    expect(Stage.idempotencyClaim("{{ikey}}", 3600, "claim")).toEqual({
+      type: "IdempotencyClaim",
+      key: "{{ikey}}",
+      ttl_secs: 3600,
+      output_field: "claim",
+    });
+    expect(Stage.rateLimit("{{user}}", 100, 60, "rl", "skip")).toMatchObject({
+      type: "RateLimit",
+      limit: 100,
+      window_secs: 60,
+      on_exceed: "skip",
+    });
+    expect(Stage.lockAcquire("{{r}}", 30, "lock")).toEqual({
+      type: "LockAcquire",
+      key: "{{r}}",
+      ttl_secs: 30,
+      output_field: "lock",
+    });
+    expect(Stage.lockRelease("{{r}}", "{{lock.token}}", "rel")).toEqual({
+      type: "LockRelease",
+      key: "{{r}}",
+      token: "{{lock.token}}",
+      output_field: "rel",
+    });
+  });
+
+  it("crypto + concurrency stages round-trip through JSON unchanged", () => {
+    const stages = [
+      Stage.hmacSign("a", "k", "m", { algorithm: "sha256", encoding: "hex" }),
+      Stage.aesEncrypt("p", "k", "e", "hex"),
+      Stage.uuidGenerate("id"),
+      Stage.totpGenerate("s", "c", {
+        digits: 6,
+        period: 30,
+        algorithm: "sha1",
+      }),
+      Stage.idempotencyClaim("k", 60, "f"),
+      Stage.rateLimit("k", 5, 60, "rl"),
+      Stage.lockAcquire("r", 60, "l"),
+    ];
+    for (const s of stages) {
+      const wire = JSON.parse(JSON.stringify(s));
+      expect(wire.type).toBe(s.type);
+    }
+  });
+});