okengine 0.11.2 → 0.13.0

package/src/console/ui-next/src/features/store/lib/files-meta.ts

@@ -0,0 +1,259 @@
+/**
+ * Files browse metadata — kind, MIME, and labels from an object key.
+ */
+
+export {
+  coerceSafeFileObjectKey,
+  isAsciiObjectKey,
+  safeFileObjectKey,
+} from "../../../../../../elements/store/files-policy.ts";
+
+/** Operator-facing object kind inferred from the key suffix. */
+export type FileKind =
+  | "image"
+  | "text"
+  | "code"
+  | "pdf"
+  | "patch"
+  | "video"
+  | "audio"
+  | "archive"
+  | "binary";
+
+/** How the inspector should render a kind. */
+export type FilePreviewMode = "image" | "text" | "pdf" | "video" | "audio" | "none";
+
+const IMAGE = new Set(["png", "jpg", "jpeg", "gif", "webp", "svg", "avif", "bmp", "ico"]);
+const TEXT = new Set([
+  "txt",
+  "md",
+  "csv",
+  "tsv",
+  "log",
+  "json",
+  "xml",
+  "yml",
+  "yaml",
+  "toml",
+  "ini",
+  "cfg",
+  "conf",
+]);
+const CODE = new Set([
+  "ts",
+  "tsx",
+  "js",
+  "jsx",
+  "mjs",
+  "cjs",
+  "css",
+  "html",
+  "htm",
+  "sql",
+  "go",
+  "rs",
+  "py",
+  "rb",
+  "sh",
+  "bash",
+  "zsh",
+  "java",
+  "kt",
+  "c",
+  "h",
+  "cpp",
+  "hpp",
+  "swift",
+  "proto",
+  "graphql",
+  "vue",
+  "svelte",
+]);
+const VIDEO = new Set(["mp4", "webm", "mov", "m4v", "ogv"]);
+const AUDIO = new Set(["mp3", "wav", "ogg", "m4a", "aac", "flac", "opus", "oga"]);
+const ARCHIVE = new Set(["zip", "tar", "gz", "tgz", "7z"]);
+
+const MIME: Record<string, string> = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  svg: "image/svg+xml",
+  avif: "image/avif",
+  bmp: "image/bmp",
+  ico: "image/x-icon",
+  txt: "text/plain",
+  md: "text/markdown",
+  csv: "text/csv",
+  tsv: "text/tab-separated-values",
+  log: "text/plain",
+  json: "application/json",
+  xml: "application/xml",
+  yml: "text/yaml",
+  yaml: "text/yaml",
+  toml: "text/plain",
+  html: "text/html",
+  css: "text/css",
+  js: "text/javascript",
+  mjs: "text/javascript",
+  ts: "text/plain",
+  tsx: "text/plain",
+  jsx: "text/plain",
+  sql: "text/plain",
+  pdf: "application/pdf",
+  patch: "text/x-patch",
+  diff: "text/x-patch",
+  mp4: "video/mp4",
+  webm: "video/webm",
+  mov: "video/quicktime",
+  m4v: "video/mp4",
+  ogv: "video/ogg",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  ogg: "audio/ogg",
+  oga: "audio/ogg",
+  m4a: "audio/mp4",
+  aac: "audio/aac",
+  flac: "audio/flac",
+  opus: "audio/opus",
+  zip: "application/zip",
+  tar: "application/x-tar",
+  gz: "application/gzip",
+};
+
+/**
+ * Last path segment of an object key (`a/b/c.pdf` → `c.pdf`).
+ *
+ * @param key - Object key
+ */
+export function fileNameFromKey(key: string): string {
+  const trimmed = key.replace(/\/+$/, "");
+  const slash = trimmed.lastIndexOf("/");
+  return slash === -1 ? trimmed : trimmed.slice(slash + 1);
+}
+
+/**
+ * Lowercase extension without the dot (`spec.pdf` → `pdf`).
+ *
+ * @param name - File name or key
+ */
+export function fileExtension(name: string): string {
+  const base = fileNameFromKey(name);
+  const dot = base.lastIndexOf(".");
+  if (dot <= 0 || dot === base.length - 1) return "";
+  return base.slice(dot + 1).toLowerCase();
+}
+
+/**
+ * Infer a browse kind from the key suffix.
+ *
+ * @param name - File name or key
+ */
+export function fileKindFromName(name: string): FileKind {
+  const ext = fileExtension(name);
+  if (ext === "pdf") return "pdf";
+  if (ext === "patch" || ext === "diff") return "patch";
+  if (IMAGE.has(ext)) return "image";
+  if (VIDEO.has(ext)) return "video";
+  if (AUDIO.has(ext)) return "audio";
+  if (ARCHIVE.has(ext)) return "archive";
+  if (CODE.has(ext)) return "code";
+  if (TEXT.has(ext)) return "text";
+  return "binary";
+}
+
+/**
+ * MIME type for preview / download. Unknown suffixes → `application/octet-stream`.
+ *
+ * @param name - File name or key
+ */
+export function inferContentType(name: string): string {
+  const ext = fileExtension(name);
+  return MIME[ext] ?? "application/octet-stream";
+}
+
+/**
+ * Short label for a {@link FileKind}.
+ *
+ * @param kind - Inferred kind
+ */
+export function fileKindLabel(kind: FileKind): string {
+  switch (kind) {
+    case "image":
+      return "Image";
+    case "text":
+      return "Text";
+    case "code":
+      return "Code";
+    case "pdf":
+      return "PDF";
+    case "patch":
+      return "Patch";
+    case "video":
+      return "Video";
+    case "audio":
+      return "Audio";
+    case "archive":
+      return "Archive";
+    case "binary":
+      return "Binary";
+  }
+}
+
+/**
+ * Whether the kind can render as UTF-8 in the inspector.
+ *
+ * @param kind - Inferred kind
+ */
+export function fileKindIsText(kind: FileKind): boolean {
+  return kind === "text" || kind === "code" || kind === "patch";
+}
+
+/**
+ * Whether the kind can render as an `<img>` in the inspector.
+ *
+ * @param kind - Inferred kind
+ */
+export function fileKindIsImage(kind: FileKind): boolean {
+  return kind === "image";
+}
+
+/**
+ * Inspector surface for a kind (`none` → download fallback).
+ *
+ * @param kind - Inferred kind
+ */
+export function filePreviewMode(kind: FileKind): FilePreviewMode {
+  switch (kind) {
+    case "image":
+      return "image";
+    case "text":
+    case "code":
+    case "patch":
+      return "text";
+    case "pdf":
+      return "pdf";
+    case "video":
+      return "video";
+    case "audio":
+      return "audio";
+    default:
+      return "none";
+  }
+}
+
+/**
+ * Pretty-print JSON; leave other text as stored.
+ *
+ * @param text - UTF-8 body
+ * @param name - File name or key
+ */
+export function formatFilePreviewText(text: string, name: string): string {
+  if (fileExtension(name) !== "json") return text;
+  try {
+    return JSON.stringify(JSON.parse(text) as unknown, null, 2);
+  } catch {
+    return text;
+  }
+}

package/src/console/ui-next/src/features/store/lib/files-origin.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, test } from "bun:test";
+import type { StoreListStore } from "@/client.ts";
+import { filesDriverLabel, filesDriverOrigin, isSingletonFilesBucket } from "./files-origin.ts";
+
+const emptyWillNot = {
+  writerFlowIds: [] as string[],
+  signals: [] as string[],
+  channels: [] as string[],
+};
+
+const emptyCache = {
+  producedByRead: "computed:files:attachments",
+  invalidatedByWrites: [] as string[],
+  invalidatingFlowIds: [] as string[],
+};
+
+function filesStore(
+  extras: Partial<StoreListStore> & Pick<StoreListStore, "name" | "children">,
+): StoreListStore {
+  return {
+    ref: `files:${extras.name}`,
+    facet: "files",
+    replicaLagMs: null,
+    migrationDrift: null,
+    contentAddressed: true,
+    warnings: [],
+    ...extras,
+  };
+}
+
+function bucket(name: string) {
+  return {
+    name,
+    effectRef: `files:${name}`,
+    writers: [],
+    readers: [],
+    cache: emptyCache,
+    willNotFire: emptyWillNot,
+    piiColumns: [],
+    columnDescriptions: {},
+  };
+}
+
+describe("isSingletonFilesBucket", () => {
+  test("true when the only child shares the store name", () => {
+    expect(
+      isSingletonFilesBucket(
+        filesStore({ name: "attachments", children: [bucket("attachments")] }),
+      ),
+    ).toBe(true);
+  });
+
+  test("false when the store has several buckets", () => {
+    expect(
+      isSingletonFilesBucket(
+        filesStore({ name: "uploads", children: [bucket("avatars"), bucket("exports")] }),
+      ),
+    ).toBe(false);
+  });
+});
+
+describe("files driver copy", () => {
+  test("labels the three files drivers", () => {
+    expect(filesDriverLabel("memory")).toBe("memory");
+    expect(filesDriverOrigin("memory")).toBe("This process");
+    expect(filesDriverOrigin("fs")).toBe("Local disk");
+    expect(filesDriverOrigin("s3")).toBe("Object store");
+  });
+});

package/src/console/ui-next/src/features/store/lib/files-origin.ts

@@ -0,0 +1,53 @@
+/**
+ * Files bucket identity — Manifest name + driver origin.
+ *
+ * A bucket is declared on `store.files(name, { buckets })`. When `buckets`
+ * is omitted, the store name is the one bucket. Bytes live on the files
+ * driver for this environment: `memory` (this process), `fs` (local disk),
+ * or `s3` (object store).
+ */
+
+import type { StoreListStore } from "@/client.ts";
+
+/** Files driver ids the Console can surface. */
+export type FilesDriverId = "memory" | "fs" | "s3";
+
+/**
+ * True when the store is one bucket that shares the store name.
+ * The tree should show a single leaf — not `attachments` → `attachments`.
+ *
+ * @param store - Projected store row
+ */
+export function isSingletonFilesBucket(store: StoreListStore): boolean {
+  if (store.facet !== "files") return false;
+  const only = store.children[0];
+  return store.children.length === 1 && only !== undefined && only.name === store.name;
+}
+
+/**
+ * Short driver chip (`memory` / `fs` / `s3`).
+ *
+ * @param driverId - Files driver, if known
+ */
+export function filesDriverLabel(driverId: string | undefined): string {
+  if (driverId === "memory" || driverId === "fs" || driverId === "s3") return driverId;
+  return "files";
+}
+
+/**
+ * Where the bucket's bytes live.
+ *
+ * @param driverId - Files driver, if known
+ */
+export function filesDriverOrigin(driverId: string | undefined): string {
+  switch (driverId) {
+    case "memory":
+      return "This process";
+    case "fs":
+      return "Local disk";
+    case "s3":
+      return "Object store";
+    default:
+      return "Files driver";
+  }
+}

package/src/console/ui-next/src/features/store/lib/files-tree.test.ts

@@ -0,0 +1,123 @@
+import { describe, expect, test } from "bun:test";
+import {
+  browseFileKeys,
+  fileBrowserCrumbs,
+  filePrefixCrumbs,
+  joinFileKey,
+  joinFilePrefix,
+  keysUnderPrefix,
+  normalizeFilePrefix,
+  parentFilePrefix,
+  searchFileKeys,
+} from "./files-tree.ts";
+
+const KEYS = [
+  { key: "attachments/ENG-184/spec.pdf", sizeBytes: 10 },
+  { key: "attachments/ENG-184/pr-diff.patch", sizeBytes: 20 },
+  { key: "attachments/DES-200/note-1.txt", sizeBytes: 5 },
+  {
+    key: "вложения/SUP-12/screenshot.png",
+    sizeBytes: 8,
+    warnings: [{ code: "non_ascii_key", message: "bad" }],
+  },
+  { key: "readme.md", sizeBytes: 3 },
+  {
+    key: "attachments/DES-200/file-ab12.pdf",
+    originalName: "رخصة عمل.pdf",
+    sizeBytes: 40,
+  },
+] as const;
+
+describe("normalizeFilePrefix", () => {
+  test("empty or trailing-slash form", () => {
+    expect(normalizeFilePrefix("")).toBe("");
+    expect(normalizeFilePrefix("/")).toBe("");
+    expect(normalizeFilePrefix("attachments")).toBe("attachments/");
+    expect(normalizeFilePrefix("/attachments/ENG-184/")).toBe("attachments/ENG-184/");
+  });
+});
+
+describe("parentFilePrefix / join", () => {
+  test("walks up and down", () => {
+    expect(parentFilePrefix("attachments/ENG-184/")).toBe("attachments/");
+    expect(parentFilePrefix("attachments/")).toBe("");
+    expect(parentFilePrefix("")).toBe("");
+    expect(joinFilePrefix("attachments/", "ENG-184")).toBe("attachments/ENG-184/");
+    expect(joinFileKey("attachments/ENG-184/", "spec.pdf")).toBe("attachments/ENG-184/spec.pdf");
+  });
+});
+
+describe("filePrefixCrumbs", () => {
+  test("root is empty; nested prefixes accumulate", () => {
+    expect(filePrefixCrumbs("")).toEqual([]);
+    expect(filePrefixCrumbs("attachments/ENG-184/")).toEqual([
+      { name: "attachments", prefix: "attachments/" },
+      { name: "ENG-184", prefix: "attachments/ENG-184/" },
+    ]);
+  });
+});
+
+describe("fileBrowserCrumbs", () => {
+  test("drops a leading folder that repeats the bucket name", () => {
+    expect(fileBrowserCrumbs("attachments/DES-202/", "attachments")).toEqual([
+      { name: "DES-202", prefix: "attachments/DES-202/" },
+    ]);
+    expect(fileBrowserCrumbs("вложения/SUP-12/", "attachments")).toEqual([
+      { name: "вложения", prefix: "вложения/" },
+      { name: "SUP-12", prefix: "вложения/SUP-12/" },
+    ]);
+  });
+});
+
+describe("browseFileKeys", () => {
+  test("root shows folders + loose files", () => {
+    const { folders, files } = browseFileKeys(KEYS, "");
+    expect(folders.map((f) => f.name)).toEqual(["attachments", "вложения"]);
+    expect(files.map((f) => f.name)).toEqual(["readme.md"]);
+    expect(folders[0]?.objectCount).toBe(4);
+    expect(folders[0]?.sizeBytes).toBe(75);
+    expect(folders[1]?.warnings[0]?.code).toBe("non_ascii_key");
+  });
+
+  test("nested prefix lists issue folders then objects", () => {
+    const mid = browseFileKeys(KEYS, "attachments/");
+    expect(mid.folders.map((f) => f.name)).toEqual(["DES-200", "ENG-184"]);
+    expect(mid.files).toEqual([]);
+
+    const leaf = browseFileKeys(KEYS, "attachments/ENG-184/");
+    expect(leaf.folders).toEqual([]);
+    expect(leaf.files.map((f) => f.name)).toEqual(["pr-diff.patch", "spec.pdf"]);
+
+    const named = browseFileKeys(KEYS, "attachments/DES-200/");
+    expect(named.files.map((f) => f.name)).toEqual(["note-1.txt", "رخصة عمل.pdf"]);
+    expect(named.files.find((f) => f.name === "رخصة عمل.pdf")?.key).toBe(
+      "attachments/DES-200/file-ab12.pdf",
+    );
+  });
+});
+
+describe("searchFileKeys", () => {
+  test("matches key substring and keeps the full key", () => {
+    const hits = searchFileKeys(KEYS, "eng-184");
+    expect(hits.map((h) => h.key)).toEqual([
+      "attachments/ENG-184/pr-diff.patch",
+      "attachments/ENG-184/spec.pdf",
+    ]);
+    expect(hits[1]?.name).toBe("spec.pdf");
+  });
+
+  test("matches originalName when the object key is ASCII", () => {
+    const hits = searchFileKeys(KEYS, "رخصة");
+    expect(hits.map((h) => h.key)).toEqual(["attachments/DES-200/file-ab12.pdf"]);
+    expect(hits[0]?.name).toBe("رخصة عمل.pdf");
+  });
+});
+
+describe("keysUnderPrefix", () => {
+  test("folder delete collects every descendant key", () => {
+    expect(keysUnderPrefix(KEYS, "attachments/ENG-184/")).toEqual([
+      "attachments/ENG-184/spec.pdf",
+      "attachments/ENG-184/pr-diff.patch",
+    ]);
+  });
+});