@clankmates/cli 0.11.0 → 0.12.0

package/src/commands/post.ts

@@ -1,3 +1,17 @@
+import {
+  assertSinceFlags,
+  authenticatedActorKey,
+  cacheFlags,
+  cacheResult,
+  ownedPostsScope,
+  prepareCachePlan,
+  publicPostsScope,
+  saveCacheTimestamp,
+  sharedPostsScope,
+  type CachePlan,
+  type CacheResult,
+  type CacheScope,
+} from "../lib/cache";
 import {
   booleanFlag,
   integerFlag,
@@ -50,52 +64,112 @@ export async function runPostCommand(args: ParsedArgs, io: Io): Promise<void> {
     }
 
     case "list": {
+      assertSinceFlags(args);
+      const channelId = await context.client.resolveChannelId(
+        requiredChannelFlag(args.flags),
+      );
+      const cacheScope = await maybeOwnedPostsScope(args, context, channelId);
+      const cachePlan = await maybePrepareCachePlan(args, context, cacheScope);
       const response = await context.client.listChannelPosts({
-        channelId: await context.client.resolveChannelId(
-          requiredChannelFlag(args.flags),
-        ),
+        channelId,
         limit: integerFlag(args.flags, "limit", { label: "--limit" }),
         cursor: stringFlag(args.flags, "cursor"),
+        before: stringFlag(args.flags, "before"),
         order: parseLatestFirstOrder(stringFlag(args.flags, "order")),
-        since: stringFlag(args.flags, "since"),
+        since: resolvedSince(args, cachePlan),
       });
+      const savedServerTimestamp = await maybeSaveCacheTimestamp(
+        args,
+        context,
+        cacheScope,
+        response.meta,
+        response.nextCursor === undefined,
+      );
 
-      printPostCollection(args, context.outputMode, io, response);
+      printPostCollection(
+        args,
+        context.outputMode,
+        io,
+        response,
+        cacheResult(cachePlan, savedServerTimestamp),
+      );
       return;
     }
 
     case "public-list": {
+      assertSinceFlags(args);
+      const publicHandle = requiredPositional(
+        args.positionals,
+        1,
+        "Missing public handle",
+      );
+      const channelName = requiredPositional(
+        args.positionals,
+        2,
+        "Missing public channel name",
+      );
+      const cacheScope = maybePublicPostsScope(
+        args,
+        context,
+        publicHandle,
+        channelName,
+      );
+      const cachePlan = await maybePrepareCachePlan(args, context, cacheScope);
       const response = await context.client.listPublicChannelPosts({
-        publicHandle: requiredPositional(
-          args.positionals,
-          1,
-          "Missing public handle",
-        ),
-        channelName: requiredPositional(
-          args.positionals,
-          2,
-          "Missing public channel name",
-        ),
+        publicHandle,
+        channelName,
         limit: integerFlag(args.flags, "limit", { label: "--limit" }),
         cursor: stringFlag(args.flags, "cursor"),
+        before: stringFlag(args.flags, "before"),
         order: parseLatestFirstOrder(stringFlag(args.flags, "order")),
-        since: stringFlag(args.flags, "since"),
+        since: resolvedSince(args, cachePlan),
       });
+      const savedServerTimestamp = await maybeSaveCacheTimestamp(
+        args,
+        context,
+        cacheScope,
+        response.meta,
+        response.nextCursor === undefined,
+      );
 
-      printPostCollection(args, context.outputMode, io, response);
+      printPostCollection(
+        args,
+        context.outputMode,
+        io,
+        response,
+        cacheResult(cachePlan, savedServerTimestamp),
+      );
       return;
     }
 
     case "shared-list": {
+      assertSinceFlags(args);
+      const token = requiredPositional(args.positionals, 1, "Missing share token");
+      const cacheScope = maybeSharedPostsScope(args, context, token);
+      const cachePlan = await maybePrepareCachePlan(args, context, cacheScope);
       const response = await context.client.listSharedChannelPosts({
-        token: requiredPositional(args.positionals, 1, "Missing share token"),
+        token,
         limit: integerFlag(args.flags, "limit", { label: "--limit" }),
         cursor: stringFlag(args.flags, "cursor"),
+        before: stringFlag(args.flags, "before"),
         order: parseLatestFirstOrder(stringFlag(args.flags, "order")),
-        since: stringFlag(args.flags, "since"),
+        since: resolvedSince(args, cachePlan),
       });
+      const savedServerTimestamp = await maybeSaveCacheTimestamp(
+        args,
+        context,
+        cacheScope,
+        response.meta,
+        response.nextCursor === undefined,
+      );
 
-      printPostCollection(args, context.outputMode, io, response);
+      printPostCollection(
+        args,
+        context.outputMode,
+        io,
+        response,
+        cacheResult(cachePlan, savedServerTimestamp),
+      );
       return;
     }
 
@@ -234,6 +308,7 @@ function printPostCollection(
     nextCursor?: string;
     meta?: Record<string, unknown>;
   },
+  cache?: CacheResult,
 ): void {
   if (outputMode === "json") {
     printJson(
@@ -242,6 +317,7 @@ function printPostCollection(
         items: response.items,
         nextCursor: response.nextCursor,
         meta: response.meta,
+        ...(cache ? { cache } : {}),
       }),
     );
     return;
@@ -267,6 +343,8 @@ function printPostCollection(
   if (message) {
     io.stdout(message);
   }
+
+  printCacheNote(io, cache);
 }
 
 function parseLatestFirstOrder(value: string | undefined): LatestFirstOrder | undefined {
@@ -281,6 +359,103 @@ function parseLatestFirstOrder(value: string | undefined): LatestFirstOrder | un
   throw new CliError("--order must be one of: latest, oldest", 2);
 }
 
+async function maybePrepareCachePlan(
+  args: ParsedArgs,
+  context: Awaited<ReturnType<typeof createCommandContext>>,
+  scope: CacheScope | undefined,
+): Promise<CachePlan | undefined> {
+  return cacheFlags(args).sinceCache && scope
+    ? prepareCachePlan(context, scope)
+    : undefined;
+}
+
+async function maybeSaveCacheTimestamp(
+  args: ParsedArgs,
+  context: Awaited<ReturnType<typeof createCommandContext>>,
+  scope: CacheScope | undefined,
+  meta: Record<string, unknown> | undefined,
+  shouldSave: boolean,
+): Promise<string | undefined> {
+  return cacheFlags(args).saveCache && scope && shouldSave
+    ? saveCacheTimestamp(context, scope, meta)
+    : undefined;
+}
+
+async function maybeOwnedPostsScope(
+  args: ParsedArgs,
+  context: Awaited<ReturnType<typeof createCommandContext>>,
+  channelId: string,
+): Promise<CacheScope | undefined> {
+  if (!cacheFlags(args).sinceCache && !cacheFlags(args).saveCache) {
+    return undefined;
+  }
+
+  return ownedPostsScope({
+    context,
+    actorKey: await authenticatedActorKey(context),
+    channelId,
+    before: stringFlag(args.flags, "before"),
+  });
+}
+
+function maybePublicPostsScope(
+  args: ParsedArgs,
+  context: Awaited<ReturnType<typeof createCommandContext>>,
+  publicHandle: string,
+  channelName: string,
+): CacheScope | undefined {
+  if (!cacheFlags(args).sinceCache && !cacheFlags(args).saveCache) {
+    return undefined;
+  }
+
+  return publicPostsScope({
+    context,
+    publicHandle,
+    channelName,
+    before: stringFlag(args.flags, "before"),
+  });
+}
+
+function maybeSharedPostsScope(
+  args: ParsedArgs,
+  context: Awaited<ReturnType<typeof createCommandContext>>,
+  shareToken: string,
+): CacheScope | undefined {
+  if (!cacheFlags(args).sinceCache && !cacheFlags(args).saveCache) {
+    return undefined;
+  }
+
+  return sharedPostsScope({
+    context,
+    shareToken,
+    before: stringFlag(args.flags, "before"),
+  });
+}
+
+function resolvedSince(
+  args: ParsedArgs,
+  cachePlan: CachePlan | undefined,
+): string | undefined {
+  return stringFlag(args.flags, "since") ?? cachePlan?.previousServerTimestamp;
+}
+
+function printCacheNote(io: Io, cache: CacheResult | undefined): void {
+  if (!cache) {
+    return;
+  }
+
+  const details = [
+    cache.previousServerTimestamp
+      ? `used ${cache.previousServerTimestamp}`
+      : cache.hit
+        ? "used cache"
+        : "no cached timestamp",
+    cache.savedServerTimestamp ? `saved ${cache.savedServerTimestamp}` : undefined,
+  ].filter(Boolean);
+
+  io.stdout(`Cache: ${details.join("; ")}.`);
+}
+
 function renderPostDetail(
   post: { id: string; attributes: PostAttributes },
   options: { title?: string; channelId?: string } = {},

package/src/lib/args.ts

@@ -49,10 +49,21 @@ const CLI_OPTIONS = {
   "schema-stdin": { type: "boolean" },
   limit: { type: "string" },
   cursor: { type: "string" },
+  before: { type: "string" },
   order: { type: "string" },
   since: { type: "string" },
+  sinceCache: { type: "boolean" },
+  "since-cache": { type: "boolean" },
+  saveCache: { type: "boolean" },
+  "save-cache": { type: "boolean" },
   status: { type: "string" },
   mailbox: { type: "string" },
+  participant: { type: "string" },
+  participantScope: { type: "string" },
+  "participant-scope": { type: "string" },
+  query: { type: "string" },
+  hasAttachment: { type: "boolean" },
+  "has-attachment": { type: "boolean" },
 } as const;
 
 type ParsedValue = string | boolean;