@tablestore/tablestore-agent-cli 0.3.1 → 0.4.0

package/dist/dashboard-runtime/dashboard/src/app/api/v1/memory/stores/[store]/wikis/page/route.ts

@@ -0,0 +1,55 @@
+import type { NextRequest } from "next/server";
+
+import {
+  errorResponse,
+  forwardResponse,
+  handleApiError,
+  requireClients,
+} from "@/lib/server/api-helpers";
+
+import {
+  hasCallerBuildId,
+  hasCallerWikiId,
+  readExactScopeFromQuery,
+  readWikiPagePath,
+} from "../_helpers";
+import { toAgentWikiScope } from "../../_scope";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+interface RouteContext {
+  params: Promise<{ store: string }>;
+}
+
+export async function GET(request: NextRequest, context: RouteContext) {
+  try {
+    const { store } = await context.params;
+    const auth = requireClients(request);
+    if (!("wiki" in auth)) return auth;
+
+    const params = new URL(request.url).searchParams;
+    const scope = readExactScopeFromQuery(params);
+    const path = readWikiPagePath(params.get("path"));
+    if (
+      hasCallerWikiId(request) ||
+      hasCallerBuildId(request) ||
+      !scope ||
+      !path
+    ) {
+      return errorResponse("BAD_REQUEST", "Invalid Wiki page request", 400);
+    }
+
+    const response = await auth.wiki.getWikiPage(
+      {
+        memoryStoreName: store,
+        scope: toAgentWikiScope(scope),
+        path,
+      },
+      request.signal,
+    );
+    return forwardResponse(response);
+  } catch (error) {
+    return handleApiError(error);
+  }
+}

package/dist/dashboard-runtime/dashboard/src/app/api/v1/memory/stores/[store]/wikis/pages/route.ts

@@ -0,0 +1,61 @@
+import type { NextRequest } from "next/server";
+
+import {
+  errorResponse,
+  forwardResponse,
+  handleApiError,
+  requireClients,
+} from "@/lib/server/api-helpers";
+
+import {
+  hasCallerBuildId,
+  hasCallerWikiId,
+  readExactScopeFromQuery,
+  readOptionalNextToken,
+  readOptionalQueryLimit,
+} from "../_helpers";
+import { toAgentWikiScope } from "../../_scope";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+interface RouteContext {
+  params: Promise<{ store: string }>;
+}
+
+export async function GET(request: NextRequest, context: RouteContext) {
+  try {
+    const { store } = await context.params;
+    const auth = requireClients(request);
+    if (!("wiki" in auth)) return auth;
+
+    const params = new URL(request.url).searchParams;
+    const scope = readExactScopeFromQuery(params);
+    const limit = readOptionalQueryLimit(params.get("limit"));
+    const nextToken = readOptionalNextToken(params.get("nextToken"));
+    if (
+      hasCallerWikiId(request) ||
+      hasCallerBuildId(request) ||
+      !scope ||
+      !limit.ok ||
+      !nextToken.ok
+    ) {
+      return errorResponse("BAD_REQUEST", "Invalid Wiki pages request", 400);
+    }
+
+    const response = await auth.wiki.listWikiPages(
+      {
+        memoryStoreName: store,
+        scope: toAgentWikiScope(scope),
+        ...(limit.value !== undefined ? { limit: limit.value } : {}),
+        ...(nextToken.value !== undefined
+          ? { nextToken: nextToken.value }
+          : {}),
+      },
+      request.signal,
+    );
+    return forwardResponse(response);
+  } catch (error) {
+    return handleApiError(error);
+  }
+}

package/dist/dashboard-runtime/dashboard/src/app/api/v1/memory/stores/[store]/wikis/route.ts

@@ -0,0 +1,89 @@
+import type { NextRequest } from "next/server";
+
+import {
+  errorResponse,
+  forwardResponse,
+  handleApiError,
+  requireClients,
+} from "@/lib/server/api-helpers";
+
+import {
+  hasCallerWikiId,
+  readExactScopeFromQuery,
+  readOptionalWikiName,
+  readOptionalWikiSummary,
+  readWikiJsonBody,
+} from "./_helpers";
+import { toAgentWikiScope } from "../_scope";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+interface RouteContext {
+  params: Promise<{ store: string }>;
+}
+
+function invalidRequest(message: string) {
+  return errorResponse("BAD_REQUEST", message, 400);
+}
+
+export async function GET(request: NextRequest, context: RouteContext) {
+  try {
+    const { store } = await context.params;
+    const auth = requireClients(request);
+    if (!("wiki" in auth)) return auth;
+
+    const params = new URL(request.url).searchParams;
+    const scope = readExactScopeFromQuery(params);
+    if (!scope || hasCallerWikiId(request)) {
+      return invalidRequest(
+        "An exact scope without legacy Wiki identity is required",
+      );
+    }
+
+    const response = await auth.wiki.getWiki(
+      { memoryStoreName: store, scope: toAgentWikiScope(scope) },
+      request.signal,
+    );
+    return forwardResponse(response);
+  } catch (error) {
+    return handleApiError(error);
+  }
+}
+
+export async function PATCH(request: NextRequest, context: RouteContext) {
+  try {
+    const { store } = await context.params;
+    const auth = requireClients(request);
+    if (!("wiki" in auth)) return auth;
+
+    const body = await readWikiJsonBody(request);
+    if (!body || hasCallerWikiId(request, body)) {
+      return invalidRequest(
+        "An exact scope without legacy Wiki identity is required",
+      );
+    }
+    const name = readOptionalWikiName(body.name);
+    const summary = readOptionalWikiSummary(body.summary);
+    if (
+      !name.ok ||
+      !summary.ok ||
+      (name.value === undefined && summary.value === undefined)
+    ) {
+      return invalidRequest("Update requires a valid name or summary");
+    }
+
+    const response = await auth.wiki.updateWiki(
+      {
+        memoryStoreName: store,
+        scope: toAgentWikiScope(body.scope),
+        ...(name.value !== undefined ? { name: name.value } : {}),
+        ...(summary.value !== undefined ? { summary: summary.value } : {}),
+      },
+      request.signal,
+    );
+    return forwardResponse(response);
+  } catch (error) {
+    return handleApiError(error);
+  }
+}

package/dist/dashboard-runtime/dashboard/src/app/api/v1/memory/stores/[store]/wikis/search/route.ts

@@ -0,0 +1,58 @@
+import type { NextRequest } from "next/server";
+
+import {
+  errorResponse,
+  forwardResponse,
+  handleApiError,
+  requireClients,
+} from "@/lib/server/api-helpers";
+
+import {
+  hasCallerBuildId,
+  hasCallerWikiId,
+  readOptionalJsonLimit,
+  readRequiredSearchQuery,
+  readWikiJsonBody,
+} from "../_helpers";
+import { toAgentWikiScope } from "../../_scope";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+interface RouteContext {
+  params: Promise<{ store: string }>;
+}
+
+export async function POST(request: NextRequest, context: RouteContext) {
+  try {
+    const { store } = await context.params;
+    const auth = requireClients(request);
+    if (!("wiki" in auth)) return auth;
+
+    const body = await readWikiJsonBody(request);
+    const query = readRequiredSearchQuery(body?.query);
+    const limit = readOptionalJsonLimit(body?.limit);
+    if (
+      !body ||
+      hasCallerWikiId(request, body) ||
+      hasCallerBuildId(request, body) ||
+      !query ||
+      !limit.ok
+    ) {
+      return errorResponse("BAD_REQUEST", "Invalid Wiki search request", 400);
+    }
+
+    const response = await auth.wiki.searchWikiPages(
+      {
+        memoryStoreName: store,
+        scope: toAgentWikiScope(body.scope),
+        query,
+        ...(limit.value !== undefined ? { limit: limit.value } : {}),
+      },
+      request.signal,
+    );
+    return forwardResponse(response);
+  } catch (error) {
+    return handleApiError(error);
+  }
+}

package/dist/dashboard-runtime/dashboard/src/app/api/v1/memory/stores/[store]/wikis/source/route.ts

@@ -0,0 +1,230 @@
+import type { NextRequest } from "next/server";
+
+import type { StandardResponse } from "@tablestore/tablestore-agent-sdk";
+
+import {
+  errorResponse,
+  forwardResponse,
+  handleApiError,
+  requireClients,
+  successResponse,
+} from "@/lib/server/api-helpers";
+
+import {
+  assertWikiSourceContent,
+  fromWikiRawItemPath,
+  hasCallerWikiId,
+  readExactScopeFromQuery,
+  readWikiJsonBody,
+  sanitizeWikiSourceErrorResponse,
+  toPublicWikiSource,
+  toWikiRawItemPath,
+} from "../_helpers";
+import { toAgentWikiScope } from "../../_scope";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+interface RouteContext {
+  params: Promise<{ store: string }>;
+}
+
+interface SourceAddress {
+  path: string;
+  physicalPath: string;
+}
+
+function invalidRequest(message: string) {
+  return errorResponse("BAD_REQUEST", message, 400);
+}
+
+function readSourceAddress(rawPath: unknown): SourceAddress | null {
+  try {
+    const physicalPath = toWikiRawItemPath(rawPath);
+    return {
+      path: fromWikiRawItemPath(physicalPath),
+      physicalPath,
+    };
+  } catch {
+    return null;
+  }
+}
+
+function readExpectedVersionId(raw: unknown): string | null {
+  if (typeof raw !== "string") return null;
+  const versionId = raw.trim();
+  return versionId || null;
+}
+
+function currentItemId(
+  response: StandardResponse,
+  expectedPhysicalPath: string,
+): string {
+  if (
+    !response.data ||
+    typeof response.data !== "object" ||
+    Array.isArray(response.data)
+  ) {
+    throw new Error("Invalid Memory Item response");
+  }
+  const item = response.data as Record<string, unknown>;
+  if (
+    typeof item.itemId !== "string" ||
+    !item.itemId ||
+    item.path !== expectedPhysicalPath
+  ) {
+    throw new Error("Invalid Memory Item response");
+  }
+  toPublicWikiSource(item);
+  return item.itemId;
+}
+
+function safeUpdatedSource(
+  response: StandardResponse,
+  expectedPhysicalPath: string,
+) {
+  const source = toPublicWikiSource(response.data);
+  if (toWikiRawItemPath(source.path) !== expectedPhysicalPath) {
+    throw new Error("Invalid Memory Item response");
+  }
+  return source;
+}
+
+export async function GET(request: NextRequest, context: RouteContext) {
+  try {
+    const { store } = await context.params;
+    const auth = requireClients(request);
+    if (!("memory" in auth)) return auth;
+
+    const params = new URL(request.url).searchParams;
+    const scope = readExactScopeFromQuery(params);
+    if (!scope || hasCallerWikiId(request)) {
+      return invalidRequest(
+        "An exact scope without legacy Wiki identity is required",
+      );
+    }
+    const source = readSourceAddress(params.get("path"));
+    if (!source) return invalidRequest("A valid source path is required");
+
+    const response = await auth.memory.getItem(
+      {
+        memoryStoreName: store,
+        scope: toAgentWikiScope(scope),
+        path: source.physicalPath,
+        view: "full",
+      },
+      request.signal,
+    );
+    if (response.code !== "SUCCESS") {
+      return forwardResponse(sanitizeWikiSourceErrorResponse(response));
+    }
+    return successResponse(safeUpdatedSource(response, source.physicalPath));
+  } catch (error) {
+    return handleApiError(error);
+  }
+}
+
+export async function PUT(request: NextRequest, context: RouteContext) {
+  try {
+    const { store } = await context.params;
+    const auth = requireClients(request);
+    if (!("memory" in auth)) return auth;
+
+    const body = await readWikiJsonBody(request);
+    const expectedVersionId = readExpectedVersionId(body?.expectedVersionId);
+    let content: string | null = null;
+    try {
+      content = assertWikiSourceContent(body?.content);
+    } catch {
+      content = null;
+    }
+    if (
+      !body ||
+      hasCallerWikiId(request, body) ||
+      !expectedVersionId ||
+      content === null
+    ) {
+      return invalidRequest("Invalid Wiki source update request");
+    }
+    const source = readSourceAddress(body.path);
+    if (!source) return invalidRequest("Invalid Wiki source update request");
+
+    const current = await auth.memory.getItem(
+      {
+        memoryStoreName: store,
+        scope: toAgentWikiScope(body.scope),
+        path: source.physicalPath,
+        view: "full",
+      },
+      request.signal,
+    );
+    if (current.code !== "SUCCESS") {
+      return forwardResponse(sanitizeWikiSourceErrorResponse(current));
+    }
+    const itemId = currentItemId(current, source.physicalPath);
+
+    const response = await auth.memory.updateItem(
+      {
+        memoryStoreName: store,
+        scope: toAgentWikiScope(body.scope),
+        itemId,
+        content,
+        precondition: { expectedVersionId },
+        view: "full",
+      },
+      request.signal,
+    );
+    if (response.code !== "SUCCESS") {
+      return forwardResponse(sanitizeWikiSourceErrorResponse(response));
+    }
+    return successResponse(safeUpdatedSource(response, source.physicalPath));
+  } catch (error) {
+    return handleApiError(error);
+  }
+}
+
+export async function DELETE(request: NextRequest, context: RouteContext) {
+  try {
+    const { store } = await context.params;
+    const auth = requireClients(request);
+    if (!("memory" in auth)) return auth;
+
+    const body = await readWikiJsonBody(request);
+    const expectedVersionId = readExpectedVersionId(body?.expectedVersionId);
+    if (!body || hasCallerWikiId(request, body) || !expectedVersionId) {
+      return invalidRequest("Invalid Wiki source delete request");
+    }
+    const source = readSourceAddress(body.path);
+    if (!source) return invalidRequest("Invalid Wiki source delete request");
+
+    const current = await auth.memory.getItem(
+      {
+        memoryStoreName: store,
+        scope: toAgentWikiScope(body.scope),
+        path: source.physicalPath,
+        view: "full",
+      },
+      request.signal,
+    );
+    if (current.code !== "SUCCESS") {
+      return forwardResponse(sanitizeWikiSourceErrorResponse(current));
+    }
+    const itemId = currentItemId(current, source.physicalPath);
+
+    const response = await auth.memory.deleteItem(
+      {
+        memoryStoreName: store,
+        scope: toAgentWikiScope(body.scope),
+        itemId,
+        precondition: { expectedVersionId },
+      },
+      request.signal,
+    );
+    if (response.code !== "SUCCESS") {
+      return forwardResponse(sanitizeWikiSourceErrorResponse(response));
+    }
+    return successResponse({ path: source.path, deleted: true });
+  } catch (error) {
+    return handleApiError(error);
+  }
+}