add delete/get key to cli

uriva · uriva · commit f178db726a38 · 2023-12-24T15:41:25.000+02:00
diff --git a/cli/src/apiToken.ts b/cli/src/apiToken.ts
@@ -1,55 +1,13 @@
-import { getAccessToken } from "./accessToken.ts";
+import { callServer } from "./rpc.ts";
 
-const serverURL = Deno.env.get("RMMBR_SERVER");
+const list = callServer("api-token/", "GET", undefined);
+const create = callServer("api-token/", "POST", { action: "create" });
 
-type APITokenInterface =
-  | { create: true }
-  | { delete: string }
-  | { list: true }
-  | { get: true };
-
-export const apiToken = (
-  cmd: APITokenInterface,
-) => {
-  const [action, args] =
-    Object.entries(cmd).find(([action]) => action in commandMapping) ||
-    Deno.exit();
-  return getAccessToken().then(commandMapping[action](args));
-};
-
-const apiTokenRequest = (
-  method: "GET" | "POST",
-  body: undefined | Record<string, string>,
-) =>
-(accessToken: string) =>
-  fetch(`${serverURL}/api-token/`, {
-    headers: { Authorization: `Bearer ${accessToken}` },
-    method,
-    body: JSON.stringify(body),
-  }).then(
-    async (response) =>
-      response.status === 200
-        ? response.json()
-        : Promise.reject(await response.text()),
-  );
-
-const createApiToken = apiTokenRequest("POST", { action: "create" });
-const listApiTokens = apiTokenRequest("GET", undefined);
-
-const getOrCreateApiToken = (
-  accessToken: string,
-): Promise<string> =>
-  listApiTokens(accessToken).then(
-    (tokens) => tokens.length == 0 ? createApiToken(accessToken) : tokens[0],
-  );
-
-const commandMapping: Record<
-  string,
-  ((..._: string[]) => (_: string) => Promise<string>)
-> = {
-  create: () => createApiToken,
+export const apiTokenCommands = {
+  create,
+  list,
   delete: (tokenId: string) =>
-    apiTokenRequest("POST", { action: "delete", tokenId }),
-  list: () => listApiTokens,
-  get: () => getOrCreateApiToken,
+    callServer("api-token/", "POST", { action: "delete", tokenId }),
+  get: (secret: string) =>
+    list(secret).then((tokens: string[]) => tokens[0] || create(secret)),
 };
diff --git a/cli/src/index.ts b/cli/src/index.ts
@@ -1,12 +1,14 @@
-import { apiToken } from "./apiToken.ts";
-import { keyManipulation } from "./keyManipulation.ts";
+import { apiTokenCommands } from "./apiToken.ts";
+import { getAccessToken } from "./accessToken.ts";
+import { keyManipulations } from "./keyManipulation.ts";
 import { login } from "./login.ts";
 import { randomBytes } from "node:crypto";
 import yargs from "https://deno.land/x/yargs@v17.7.2-deno/deno.ts";
 
 const args = yargs(Deno.args)
   .scriptName("rmmbr")
   .command("login", "Authenticate the CLI")
+  // deno-lint-ignore no-explicit-any
   .command("key", "Manage cache keys", (yargs: any) =>
     yargs
       .option("get", {
@@ -23,10 +25,11 @@ const args = yargs(Deno.args)
   .command(
     "token",
     "Manage API tokens",
+    // deno-lint-ignore no-explicit-any
     (yargs: any) =>
       yargs.option("get", {
         alias: "g",
-        description: "(Default) Get or create the first API token",
+        description: "Get or create the first API token",
         boolean: true,
       }).option(
         "create",
@@ -60,15 +63,29 @@ const args = yargs(Deno.args)
   .version("0.1")
   .parse();
 
-const command = args._[0];
-const commands: Record<string, () => Promise<string>> = {
+type YargsInstance = ReturnType<typeof yargs>;
+type Handler = (
+  // deno-lint-ignore no-explicit-any
+  cmdInput: any,
+) => (accessToken: string) => Promise<string>;
+
+const pickAndRunCommand =
+  (availableCmds: Record<string, Handler>) => (cmdInput: YargsInstance) => {
+    const [action, args] =
+      Object.entries(cmdInput).find(([action]) => action in availableCmds) ||
+      Deno.exit();
+    return getAccessToken().then(availableCmds[action](args));
+  };
+
+// deno-lint-ignore no-explicit-any
+const commands: Record<string, (args: any) => Promise<string>> = {
   login,
-  key: () => keyManipulation(args),
-  token: () => apiToken(args),
+  key: pickAndRunCommand(keyManipulations),
+  token: pickAndRunCommand(apiTokenCommands),
   secret: () => Promise.resolve(randomBytes(32).toString("base64url") + "="),
 };
 
-commands[command]().then(console.log).catch((msg) => {
+commands[args._[0]](args).then(console.log).catch((msg) => {
   console.error(msg);
   Deno.exit(1);
 });
diff --git a/cli/src/keyManipulation.ts b/cli/src/keyManipulation.ts
@@ -1,23 +1,19 @@
-import { getAccessToken } from "./accessToken.ts";
+import { callServer } from "./rpc.ts";
+import { inputToCacheKey } from "../../client/src/index.ts";
 
-const commandMapping: Record<
-  string,
-  ((..._: string[]) => (_: string) => Promise<string>)
-> = {
-  delete: (apiToken: string) => (secretAndKey: string) =>
-    Promise.resolve("not yet implemented"),
-  get: (apiToken: string) => (secretAndKey: string) =>
-    Promise.resolve("not yet implemented"),
+const parseCacheIdAndKey = (hashKey: (...xs: any[]) => string, x: string) => {
+  const [cacheId, key] = x.split(":");
+  return { cacheId, key: hashKey(...JSON.parse(key)) };
 };
+const actOnKey = (action: string) => (args: string) => (secret: string) =>
+  callServer("", "GET", {
+    action,
+    ...parseCacheIdAndKey(inputToCacheKey(secret, undefined), args),
+  })(
+    secret,
+  );
 
-type APITokenInterface =
-  | { delete: string }
-  | { get: true };
-
-export const keyManipulation = (cmd: APITokenInterface) => {
-  const [action, args] =
-    Object.entries(cmd).find(([action]) => action in commandMapping) ||
-    Deno.exit();
-  return getAccessToken()
-    .then(commandMapping[action](args));
+export const keyManipulations = {
+  delete: actOnKey("delete"),
+  get: actOnKey("get"),
 };
diff --git a/cli/src/rpc.ts b/cli/src/rpc.ts
@@ -0,0 +1,18 @@
+const serverURL = Deno.env.get("RMMBR_SERVER");
+
+export const callServer = (
+  path: string,
+  method: "GET" | "POST",
+  body: undefined | Record<string, string>,
+) =>
+(accessToken: string) =>
+  fetch(`${serverURL}/${path}`, {
+    headers: { Authorization: `Bearer ${accessToken}` },
+    method,
+    body: JSON.stringify(body),
+  }).then(
+    async (response) =>
+      response.status === 200
+        ? response.json()
+        : Promise.reject(await response.text()),
+  );
diff --git a/client/src/index.ts b/client/src/index.ts
@@ -92,7 +92,7 @@ export const waitAllWrites = () => Promise.all(writePromises);
 
 type CustomKeyFn = (..._: any[]) => any;
 
-const inputToCacheKey =
+export const inputToCacheKey =
   // deno-lint-ignore no-explicit-any
   <Args extends any[]>(secret: string, customKeyFn: CustomKeyFn | undefined) =>
   (...x: Args): string =>
@@ -110,12 +110,12 @@ export const memCache =
       // @ts-expect-error Promise<Awaited<Awaited<X>>> is just Promise<X>
       read: (key: string) => {
         if (!(key in keyToValue)) {
-          return Promise.reject();
+          return Promise.reject(new Error());
         }
         if (ttl && Date.now() - keyToTimestamp[key] > ttl * 1000) {
           delete keyToTimestamp[key];
           delete keyToValue[key];
-          return Promise.reject();
+          return Promise.reject(new Error());
         }
         return Promise.resolve(keyToValue[key]);
       },
@@ -217,17 +217,17 @@ const cloudCache = (params: CloudCacheParams) => <F extends Func>(f: F) =>
         .then((value) =>
           value
             ? params.encryptionKey
-              ? decrypt(params.encryptionKey as string)(value).then(
+              ? decrypt(params.encryptionKey!)(value).then(
                 JSON.parse,
               )
               : value
-            : Promise.reject()
+            : Promise.reject(new Error())
         ) as ReturnType<F>,
     write: params.encryptionKey
       ? async (key, value) =>
         setRemote(params)(
           key,
-          await encrypt(params.encryptionKey as string)(
+          await encrypt(params.encryptionKey!)(
             jsonStableStringify(value),
           ),
         )
diff --git a/server/src/index.ts b/server/src/index.ts
@@ -31,8 +31,10 @@ const verifyAuth0 = (token: string): Promise<string | null> =>
     audience: "rmmbr",
   }).then((x) => x.payload.sub || null).catch(() => null);
 
-type CREATE_TOKEN = { action: "create" };
-type DELETE_TOKEN = { action: "delete"; tokenId: string };
+type ApiTokenAction = { action: "create" } | {
+  action: "delete";
+  tokenId: string;
+};
 
 serve(
   app({
@@ -41,17 +43,22 @@ serve(
         memCache({ ttl: 60 * 5 })(verifyApiToken),
         async (request, uid) => {
           const { method, params } = await request.json();
+          console.log("incoming request", method, params);
           if (method === "get") {
             const { cacheId, key } = params;
-            console.log(`incoming get request for key ${key}`);
             return new Response(
               (await redisClient.get(`${uid}:${cacheId}:${key}`)) ||
                 JSON.stringify(null),
             );
           }
+          if (method === "delete") {
+            const { cacheId, key } = params;
+            return new Response(
+              JSON.stringify(await redisClient.del(`${uid}:${cacheId}:${key}`)),
+            );
+          }
           if (method === "set") {
             const { cacheId, key, value, ttl } = params;
-            console.log(`incoming set request for key ${key}`);
             await redisClient.set(
               `${uid}:${cacheId}:${key}`,
               JSON.stringify(value),
@@ -77,16 +84,17 @@ serve(
         verifyAuth0,
         (request, uid) =>
           request.json().then(
-            (call: CREATE_TOKEN | DELETE_TOKEN) => {
-              if (call.action == "create") {
+            (call: ApiTokenAction) => {
+              if (call.action === "create") {
                 const token = crypto.randomUUID();
                 const tx = redisClient.tx();
                 tx.rpush(redisKey.userToApiTokenSet(uid), token);
                 tx.set(redisKey.apiTokenToUser(token), uid);
                 return tx.flush().then(() =>
                   new Response(JSON.stringify(token))
                 );
-              } else if (call.action == "delete") {
+              }
+              if (call.action === "delete") {
                 return getApiTokens(uid).then((tokens) => {
                   const tokensToDelete = tokens.filter((t) =>
                     t.startsWith(call.tokenId)
