wiki-graph-core 0.3.1 → 0.4.0

package/dist/storage/wikg/wikg-coordinator/file-store.js

@@ -0,0 +1,369 @@
+import { mkdir, readFile, rename, rm, writeFile } from "fs/promises";
+import { dirname, posix, resolve } from "path";
+import { ensureWikiGraphHomeSchemaCurrent } from "../../../document/home-schema-upgrade.js";
+import { readWikgArchiveEntry, WikgArchiveReader } from "../archive/index.js";
+import {
+  createArchiveKey,
+  createArchiveSignature,
+  createOwnerId
+} from "./archive-key.js";
+import {
+  DATABASE_ENTRY_PATH,
+  SEARCH_INDEX_DATABASE_ENTRY_PATH
+} from "./constants.js";
+import {
+  acquireSqliteLease,
+  releaseSqliteLease,
+  withEntryLock
+} from "./locks.js";
+import {
+  deleteOverlay,
+  listOverlays,
+  listVisibleEntryPaths,
+  readOverlay,
+  resolveEntrySource,
+  upsertOverlay
+} from "./overlays.js";
+import { tryAdoptSearchIndexCacheOverlay } from "./search-index-cache.js";
+import {
+  createWorkspaceFilePath,
+  normalizeEntryDirectoryPrefix,
+  normalizeEntryPath
+} from "./workspace.js";
+class WikgDocumentFileStore {
+  #archiveKey;
+  #archivePath;
+  #archiveReader;
+  #entrySourceByPath;
+  #readonlyDatabase;
+  #searchIndexWritebackPolicy;
+  #sqliteLeaseOwnerId = createOwnerId();
+  constructor(archivePath, options) {
+    this.#archivePath = resolve(archivePath);
+    this.#archiveKey = createArchiveKey(this.#archivePath);
+    this.#readonlyDatabase = options.readonlyDatabase === true;
+    this.#searchIndexWritebackPolicy = options.searchIndexWritebackPolicy ?? "archive";
+    this.#session = options.session;
+  }
+  async #readOverlay(entryPath) {
+    const overlay = await readOverlay(this.#archiveKey, entryPath);
+    if (overlay === void 0) {
+      return void 0;
+    }
+    const signature = await createArchiveSignature(this.#archivePath);
+    if (overlay.archiveSignature === signature) {
+      return overlay;
+    }
+    await deleteOverlay(this.#archiveKey, entryPath);
+    if (overlay.workspacePath !== void 0) {
+      await rm(overlay.workspacePath, { force: true }).catch(() => void 0);
+    }
+    this.#entrySourceByPath?.delete(entryPath);
+    return void 0;
+  }
+  #session;
+  async close() {
+    if (this.#archiveReader !== void 0) {
+      (await this.#archiveReader).close();
+      this.#archiveReader = void 0;
+    }
+    await releaseSqliteLease({
+      archiveKey: this.#archiveKey,
+      entryPath: DATABASE_ENTRY_PATH,
+      ownerId: this.#sqliteLeaseOwnerId
+    });
+    await releaseSqliteLease({
+      archiveKey: this.#archiveKey,
+      entryPath: SEARCH_INDEX_DATABASE_ENTRY_PATH,
+      ownerId: this.#sqliteLeaseOwnerId
+    });
+  }
+  async deleteFile(path) {
+    const entryPath = this.#toEntryPath(path);
+    await withEntryLock(this.#archiveKey, entryPath, "write", async () => {
+      await withEntryLock(this.#archiveKey, entryPath, "state", async () => {
+        const overlay = await this.#readOverlay(entryPath);
+        await upsertOverlay({
+          archiveKey: this.#archiveKey,
+          archivePath: this.#archivePath,
+          entryPath,
+          kind: "deleted"
+        });
+        if (overlay?.workspacePath !== void 0) {
+          await rm(overlay.workspacePath, { force: true }).catch(
+            () => void 0
+          );
+        }
+        this.#entrySourceByPath?.set(entryPath, { kind: "deleted" });
+        this.#session?.modifyEntry(entryPath);
+      });
+    });
+  }
+  async deleteTree(path) {
+    const rootEntryPath = this.#toEntryPath(path);
+    const entries = await listVisibleEntryPaths(
+      await this.#listArchiveEntries(),
+      {
+        archiveKey: this.#archiveKey,
+        prefix: `${rootEntryPath}/`
+      }
+    );
+    for (const entryPath of entries) {
+      await this.deleteFile(entryPath);
+    }
+  }
+  ensureDirectory() {
+    return Promise.resolve();
+  }
+  initializeDatabaseSchema() {
+    return false;
+  }
+  markDatabaseDirty() {
+    if (!this.#readonlyDatabase) {
+      this.#session?.observeDirtyEntry(DATABASE_ENTRY_PATH);
+    }
+  }
+  markSearchIndexDatabaseDirty() {
+    if (!this.#readonlyDatabase && this.#searchIndexWritebackPolicy === "archive") {
+      this.#session?.observeDirtyEntry(SEARCH_INDEX_DATABASE_ENTRY_PATH);
+    }
+  }
+  openDatabaseReadonly() {
+    return this.#readonlyDatabase;
+  }
+  async listFiles(path) {
+    const directoryEntryPath = this.#toEntryPath(path);
+    const prefix = directoryEntryPath === "" ? "" : `${directoryEntryPath}/`;
+    const entries = (await this.#listDirectoryEntryPaths(prefix)).map(
+      ([entryPath]) => entryPath
+    );
+    return entries.map((entryPath) => entryPath.slice(prefix.length)).filter((entryPath) => !entryPath.includes("/")).map((entryPath) => posix.basename(entryPath)).sort((left, right) => left.localeCompare(right));
+  }
+  async listFileContents(path) {
+    const directoryEntryPath = this.#toEntryPath(path);
+    const prefix = directoryEntryPath === "" ? "" : `${directoryEntryPath}/`;
+    return await withEntryLock(
+      this.#archiveKey,
+      normalizeEntryDirectoryPrefix(prefix),
+      "read",
+      async () => {
+        const contents = /* @__PURE__ */ new Map();
+        for (const [entryPath, source] of await this.#listDirectoryEntryPaths(
+          prefix
+        )) {
+          const name = entryPath.slice(prefix.length);
+          if (name.includes("/")) {
+            continue;
+          }
+          if (source.kind === "workspace") {
+            contents.set(name, await readFile(source.path));
+            continue;
+          }
+          const content = await this.#readArchiveEntry(entryPath);
+          if (content !== void 0) {
+            contents.set(name, content);
+          }
+        }
+        return contents;
+      }
+    );
+  }
+  async readFile(path) {
+    const entryPath = this.#toEntryPath(path);
+    return await withEntryLock(
+      this.#archiveKey,
+      entryPath,
+      "read",
+      async () => {
+        const source = (await this.#getEntrySources()).get(entryPath) ?? await withEntryLock(
+          this.#archiveKey,
+          entryPath,
+          "state",
+          async () => await resolveEntrySource({
+            archiveKey: this.#archiveKey,
+            entryPath
+          })
+        );
+        if (source.kind === "deleted") {
+          this.#session?.observeDirtyEntry(entryPath);
+          return void 0;
+        }
+        if (source.kind === "workspace") {
+          this.#session?.observeDirtyEntry(entryPath);
+          return await readFile(source.path);
+        }
+        return await this.#readArchiveEntry(entryPath);
+      }
+    );
+  }
+  async resolveDatabasePath() {
+    return await this.#resolveSqliteDatabasePath(DATABASE_ENTRY_PATH, {
+      createIfMissing: true,
+      readonly: this.#readonlyDatabase
+    });
+  }
+  async resolveSearchIndexDatabasePath() {
+    return await this.#resolveSqliteDatabasePath(
+      SEARCH_INDEX_DATABASE_ENTRY_PATH,
+      {
+        createIfMissing: !this.#readonlyDatabase,
+        readonly: this.#readonlyDatabase
+      }
+    );
+  }
+  async #resolveSqliteDatabasePath(entryPath, options) {
+    if (entryPath === SEARCH_INDEX_DATABASE_ENTRY_PATH) {
+      await ensureWikiGraphHomeSchemaCurrent();
+    }
+    return await withEntryLock(
+      this.#archiveKey,
+      entryPath,
+      "state",
+      async () => {
+        let overlay = await this.#readOverlay(entryPath);
+        if (entryPath === SEARCH_INDEX_DATABASE_ENTRY_PATH && overlay?.kind !== "file") {
+          await tryAdoptSearchIndexCacheOverlay({
+            targetArchiveKey: this.#archiveKey,
+            targetArchivePath: this.#archivePath
+          });
+          overlay = await this.#readOverlay(entryPath);
+        }
+        if (overlay?.kind !== "file") {
+          const content = await readWikgArchiveEntry(
+            this.#archivePath,
+            entryPath
+          );
+          if (content === void 0 && !options.createIfMissing) {
+            throw new Error(`Archive SQLite entry is missing: ${entryPath}`);
+          }
+          const workspacePath = await createWorkspaceFilePath(
+            this.#archiveKey,
+            entryPath
+          );
+          await mkdir(dirname(workspacePath), { recursive: true });
+          await writeFile(workspacePath, content ?? new Uint8Array());
+          await upsertOverlay({
+            archiveKey: this.#archiveKey,
+            archivePath: this.#archivePath,
+            entryPath,
+            kind: "file",
+            workspacePath
+          });
+          overlay = await this.#readOverlay(entryPath);
+        }
+        if (overlay?.workspacePath === void 0) {
+          throw new Error("Could not materialize SQLite database.");
+        }
+        await acquireSqliteLease({
+          archiveKey: this.#archiveKey,
+          entryPath,
+          mode: options.readonly ? "read" : "write",
+          ownerId: this.#sqliteLeaseOwnerId
+        });
+        return overlay.workspacePath;
+      }
+    );
+  }
+  async writeFile(path, content, options) {
+    const entryPath = this.#toEntryPath(path);
+    await withEntryLock(this.#archiveKey, entryPath, "write", async () => {
+      const source = await withEntryLock(
+        this.#archiveKey,
+        entryPath,
+        "state",
+        async () => await resolveEntrySource({
+          archiveKey: this.#archiveKey,
+          entryPath
+        })
+      );
+      const archiveEntryExists = source.kind === "archive" && await this.#readArchiveEntry(entryPath) !== void 0;
+      if (options.overwrite !== true && (source.kind === "workspace" || archiveEntryExists)) {
+        throw new Error(`File already exists: ${path}`);
+      }
+      await withEntryLock(this.#archiveKey, entryPath, "state", async () => {
+        const workspacePath = await createWorkspaceFilePath(
+          this.#archiveKey,
+          entryPath
+        );
+        await mkdir(dirname(workspacePath), { recursive: true });
+        const temporaryWorkspacePath = `${workspacePath}.${process.pid}.${Date.now()}.tmp`;
+        try {
+          await writeFile(temporaryWorkspacePath, content);
+          await rename(temporaryWorkspacePath, workspacePath);
+        } finally {
+          await rm(temporaryWorkspacePath, { force: true }).catch(
+            () => void 0
+          );
+        }
+        await upsertOverlay({
+          archiveKey: this.#archiveKey,
+          archivePath: this.#archivePath,
+          entryPath,
+          kind: "file",
+          workspacePath
+        });
+        this.#entrySourceByPath?.set(entryPath, {
+          kind: "workspace",
+          path: workspacePath
+        });
+        if (source.kind === "workspace" && source.path !== workspacePath) {
+          await rm(source.path, { force: true }).catch(() => void 0);
+        }
+        this.#session?.modifyEntry(entryPath);
+      });
+    });
+  }
+  #toEntryPath(path) {
+    const resolvedPath = resolve(path);
+    const rootPrefix = this.#archivePath.endsWith("/") ? this.#archivePath : `${this.#archivePath}/`;
+    if (resolvedPath.startsWith(rootPrefix)) {
+      return normalizeEntryPath(resolvedPath.slice(rootPrefix.length));
+    }
+    return normalizeEntryPath(path);
+  }
+  async #listArchiveEntries() {
+    return (await this.#getArchiveReader()).listEntries();
+  }
+  async #readArchiveEntry(entryPath) {
+    return await (await this.#getArchiveReader()).readEntry(entryPath);
+  }
+  async #getArchiveReader() {
+    this.#archiveReader ??= WikgArchiveReader.open(this.#archivePath);
+    return await this.#archiveReader;
+  }
+  async #getEntrySources() {
+    if (this.#entrySourceByPath !== void 0) {
+      return this.#entrySourceByPath;
+    }
+    const entries = /* @__PURE__ */ new Map();
+    for (const entryPath of await this.#listArchiveEntries()) {
+      entries.set(entryPath, { kind: "archive" });
+    }
+    for (const overlay of await listOverlays(this.#archiveKey)) {
+      if (overlay.kind === "deleted") {
+        entries.set(overlay.entryPath, { kind: "deleted" });
+      } else if (overlay.workspacePath !== void 0) {
+        entries.set(overlay.entryPath, {
+          kind: "workspace",
+          path: overlay.workspacePath
+        });
+      }
+    }
+    this.#entrySourceByPath = entries;
+    return entries;
+  }
+  async #listDirectoryEntryPaths(prefix) {
+    const entries = [];
+    for (const [entryPath, source] of await this.#getEntrySources()) {
+      if (source.kind === "deleted" || !entryPath.startsWith(prefix)) {
+        continue;
+      }
+      entries.push([entryPath, source]);
+    }
+    return entries.sort(([left], [right]) => left.localeCompare(right));
+  }
+}
+export {
+  WikgDocumentFileStore
+};
+//# sourceMappingURL=file-store.js.map

package/dist/storage/wikg/wikg-coordinator/file-store.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/storage/wikg/wikg-coordinator/file-store.ts"],"sourcesContent":["import { mkdir, readFile, rename, rm, writeFile } from \"fs/promises\";\nimport { dirname, posix, resolve } from \"path\";\n\nimport type { DocumentFileStore } from \"../../../document/directory/index.js\";\nimport { ensureWikiGraphHomeSchemaCurrent } from \"../../../document/home-schema-upgrade.js\";\n\nimport { readWikgArchiveEntry, WikgArchiveReader } from \"../archive/index.js\";\n\nimport {\n  createArchiveKey,\n  createArchiveSignature,\n  createOwnerId,\n} from \"./archive-key.js\";\nimport {\n  DATABASE_ENTRY_PATH,\n  SEARCH_INDEX_DATABASE_ENTRY_PATH,\n} from \"./constants.js\";\nimport {\n  acquireSqliteLease,\n  releaseSqliteLease,\n  withEntryLock,\n} from \"./locks.js\";\nimport {\n  deleteOverlay,\n  listOverlays,\n  listVisibleEntryPaths,\n  readOverlay,\n  resolveEntrySource,\n  upsertOverlay,\n} from \"./overlays.js\";\nimport { tryAdoptSearchIndexCacheOverlay } from \"./search-index-cache.js\";\nimport type { EntryOverlay, WorkspaceWritebackPolicy } from \"./types.js\";\nimport {\n  createWorkspaceFilePath,\n  normalizeEntryDirectoryPrefix,\n  normalizeEntryPath,\n} from \"./workspace.js\";\nimport type { WikgArchiveSession } from \"./session.js\";\n\nexport class WikgDocumentFileStore implements DocumentFileStore {\n  readonly #archiveKey: string;\n  readonly #archivePath: string;\n  #archiveReader: Promise<WikgArchiveReader> | undefined;\n  #entrySourceByPath:\n    | Map<\n        string,\n        | { readonly kind: \"archive\" }\n        | { readonly kind: \"deleted\" }\n        | { readonly kind: \"workspace\"; readonly path: string }\n      >\n    | undefined;\n  readonly #readonlyDatabase: boolean;\n  readonly #searchIndexWritebackPolicy: WorkspaceWritebackPolicy;\n  readonly #sqliteLeaseOwnerId = createOwnerId();\n\n  public constructor(\n    archivePath: string,\n    options: {\n      readonly readonlyDatabase?: boolean;\n      readonly searchIndexWritebackPolicy?: WorkspaceWritebackPolicy;\n      readonly session?: WikgArchiveSession;\n    },\n  ) {\n    this.#archivePath = resolve(archivePath);\n    this.#archiveKey = createArchiveKey(this.#archivePath);\n    this.#readonlyDatabase = options.readonlyDatabase === true;\n    this.#searchIndexWritebackPolicy =\n      options.searchIndexWritebackPolicy ?? \"archive\";\n    this.#session = options.session;\n  }\n\n  async #readOverlay(entryPath: string): Promise<EntryOverlay | undefined> {\n    const overlay = await readOverlay(this.#archiveKey, entryPath);\n\n    if (overlay === undefined) {\n      return undefined;\n    }\n\n    const signature = await createArchiveSignature(this.#archivePath);\n\n    if (overlay.archiveSignature === signature) {\n      return overlay;\n    }\n\n    await deleteOverlay(this.#archiveKey, entryPath);\n    if (overlay.workspacePath !== undefined) {\n      await rm(overlay.workspacePath, { force: true }).catch(() => undefined);\n    }\n    this.#entrySourceByPath?.delete(entryPath);\n    return undefined;\n  }\n\n  readonly #session: WikgArchiveSession | undefined;\n\n  public async close(): Promise<void> {\n    if (this.#archiveReader !== undefined) {\n      (await this.#archiveReader).close();\n      this.#archiveReader = undefined;\n    }\n    await releaseSqliteLease({\n      archiveKey: this.#archiveKey,\n      entryPath: DATABASE_ENTRY_PATH,\n      ownerId: this.#sqliteLeaseOwnerId,\n    });\n    await releaseSqliteLease({\n      archiveKey: this.#archiveKey,\n      entryPath: SEARCH_INDEX_DATABASE_ENTRY_PATH,\n      ownerId: this.#sqliteLeaseOwnerId,\n    });\n  }\n\n  public async deleteFile(path: string): Promise<void> {\n    const entryPath = this.#toEntryPath(path);\n\n    await withEntryLock(this.#archiveKey, entryPath, \"write\", async () => {\n      await withEntryLock(this.#archiveKey, entryPath, \"state\", async () => {\n        const overlay = await this.#readOverlay(entryPath);\n\n        await upsertOverlay({\n          archiveKey: this.#archiveKey,\n          archivePath: this.#archivePath,\n          entryPath,\n          kind: \"deleted\",\n        });\n        if (overlay?.workspacePath !== undefined) {\n          await rm(overlay.workspacePath, { force: true }).catch(\n            () => undefined,\n          );\n        }\n        this.#entrySourceByPath?.set(entryPath, { kind: \"deleted\" });\n        this.#session?.modifyEntry(entryPath);\n      });\n    });\n  }\n\n  public async deleteTree(path: string): Promise<void> {\n    const rootEntryPath = this.#toEntryPath(path);\n    const entries = await listVisibleEntryPaths(\n      await this.#listArchiveEntries(),\n      {\n        archiveKey: this.#archiveKey,\n        prefix: `${rootEntryPath}/`,\n      },\n    );\n\n    for (const entryPath of entries) {\n      await this.deleteFile(entryPath);\n    }\n  }\n\n  public ensureDirectory(): Promise<void> {\n    return Promise.resolve();\n  }\n\n  public initializeDatabaseSchema(): boolean {\n    return false;\n  }\n\n  public markDatabaseDirty(): void {\n    if (!this.#readonlyDatabase) {\n      this.#session?.observeDirtyEntry(DATABASE_ENTRY_PATH);\n    }\n  }\n\n  public markSearchIndexDatabaseDirty(): void {\n    if (\n      !this.#readonlyDatabase &&\n      this.#searchIndexWritebackPolicy === \"archive\"\n    ) {\n      this.#session?.observeDirtyEntry(SEARCH_INDEX_DATABASE_ENTRY_PATH);\n    }\n  }\n\n  public openDatabaseReadonly(): boolean {\n    return this.#readonlyDatabase;\n  }\n\n  public async listFiles(path: string): Promise<readonly string[]> {\n    const directoryEntryPath = this.#toEntryPath(path);\n    const prefix = directoryEntryPath === \"\" ? \"\" : `${directoryEntryPath}/`;\n    const entries = (await this.#listDirectoryEntryPaths(prefix)).map(\n      ([entryPath]) => entryPath,\n    );\n\n    return entries\n      .map((entryPath) => entryPath.slice(prefix.length))\n      .filter((entryPath) => !entryPath.includes(\"/\"))\n      .map((entryPath) => posix.basename(entryPath))\n      .sort((left, right) => left.localeCompare(right));\n  }\n\n  public async listFileContents(\n    path: string,\n  ): Promise<ReadonlyMap<string, Uint8Array>> {\n    const directoryEntryPath = this.#toEntryPath(path);\n    const prefix = directoryEntryPath === \"\" ? \"\" : `${directoryEntryPath}/`;\n    return await withEntryLock(\n      this.#archiveKey,\n      normalizeEntryDirectoryPrefix(prefix),\n      \"read\",\n      async () => {\n        const contents = new Map<string, Uint8Array>();\n\n        for (const [entryPath, source] of await this.#listDirectoryEntryPaths(\n          prefix,\n        )) {\n          const name = entryPath.slice(prefix.length);\n\n          if (name.includes(\"/\")) {\n            continue;\n          }\n          if (source.kind === \"workspace\") {\n            contents.set(name, await readFile(source.path));\n            continue;\n          }\n\n          const content = await this.#readArchiveEntry(entryPath);\n\n          if (content !== undefined) {\n            contents.set(name, content);\n          }\n        }\n\n        return contents;\n      },\n    );\n  }\n\n  public async readFile(path: string): Promise<Uint8Array | undefined> {\n    const entryPath = this.#toEntryPath(path);\n\n    return await withEntryLock(\n      this.#archiveKey,\n      entryPath,\n      \"read\",\n      async () => {\n        const source =\n          (await this.#getEntrySources()).get(entryPath) ??\n          (await withEntryLock(\n            this.#archiveKey,\n            entryPath,\n            \"state\",\n            async () =>\n              await resolveEntrySource({\n                archiveKey: this.#archiveKey,\n                entryPath,\n              }),\n          ));\n\n        if (source.kind === \"deleted\") {\n          this.#session?.observeDirtyEntry(entryPath);\n          return undefined;\n        }\n        if (source.kind === \"workspace\") {\n          this.#session?.observeDirtyEntry(entryPath);\n          return await readFile(source.path);\n        }\n\n        return await this.#readArchiveEntry(entryPath);\n      },\n    );\n  }\n\n  public async resolveDatabasePath(): Promise<string> {\n    return await this.#resolveSqliteDatabasePath(DATABASE_ENTRY_PATH, {\n      createIfMissing: true,\n      readonly: this.#readonlyDatabase,\n    });\n  }\n\n  public async resolveSearchIndexDatabasePath(): Promise<string> {\n    return await this.#resolveSqliteDatabasePath(\n      SEARCH_INDEX_DATABASE_ENTRY_PATH,\n      {\n        createIfMissing: !this.#readonlyDatabase,\n        readonly: this.#readonlyDatabase,\n      },\n    );\n  }\n\n  async #resolveSqliteDatabasePath(\n    entryPath: string,\n    options: { readonly createIfMissing: boolean; readonly readonly: boolean },\n  ): Promise<string> {\n    if (entryPath === SEARCH_INDEX_DATABASE_ENTRY_PATH) {\n      await ensureWikiGraphHomeSchemaCurrent();\n    }\n\n    return await withEntryLock(\n      this.#archiveKey,\n      entryPath,\n      \"state\",\n      async () => {\n        let overlay = await this.#readOverlay(entryPath);\n\n        if (\n          entryPath === SEARCH_INDEX_DATABASE_ENTRY_PATH &&\n          overlay?.kind !== \"file\"\n        ) {\n          await tryAdoptSearchIndexCacheOverlay({\n            targetArchiveKey: this.#archiveKey,\n            targetArchivePath: this.#archivePath,\n          });\n          overlay = await this.#readOverlay(entryPath);\n        }\n\n        if (overlay?.kind !== \"file\") {\n          const content = await readWikgArchiveEntry(\n            this.#archivePath,\n            entryPath,\n          );\n\n          if (content === undefined && !options.createIfMissing) {\n            throw new Error(`Archive SQLite entry is missing: ${entryPath}`);\n          }\n          const workspacePath = await createWorkspaceFilePath(\n            this.#archiveKey,\n            entryPath,\n          );\n\n          await mkdir(dirname(workspacePath), { recursive: true });\n          await writeFile(workspacePath, content ?? new Uint8Array());\n          await upsertOverlay({\n            archiveKey: this.#archiveKey,\n            archivePath: this.#archivePath,\n            entryPath,\n            kind: \"file\",\n            workspacePath,\n          });\n          overlay = await this.#readOverlay(entryPath);\n        }\n\n        if (overlay?.workspacePath === undefined) {\n          throw new Error(\"Could not materialize SQLite database.\");\n        }\n\n        await acquireSqliteLease({\n          archiveKey: this.#archiveKey,\n          entryPath,\n          mode: options.readonly ? \"read\" : \"write\",\n          ownerId: this.#sqliteLeaseOwnerId,\n        });\n        return overlay.workspacePath;\n      },\n    );\n  }\n\n  public async writeFile(\n    path: string,\n    content: string | Uint8Array,\n    options: { readonly overwrite?: boolean },\n  ): Promise<void> {\n    const entryPath = this.#toEntryPath(path);\n\n    await withEntryLock(this.#archiveKey, entryPath, \"write\", async () => {\n      const source = await withEntryLock(\n        this.#archiveKey,\n        entryPath,\n        \"state\",\n        async () =>\n          await resolveEntrySource({\n            archiveKey: this.#archiveKey,\n            entryPath,\n          }),\n      );\n      const archiveEntryExists =\n        source.kind === \"archive\" &&\n        (await this.#readArchiveEntry(entryPath)) !== undefined;\n\n      if (\n        options.overwrite !== true &&\n        (source.kind === \"workspace\" || archiveEntryExists)\n      ) {\n        throw new Error(`File already exists: ${path}`);\n      }\n\n      await withEntryLock(this.#archiveKey, entryPath, \"state\", async () => {\n        const workspacePath = await createWorkspaceFilePath(\n          this.#archiveKey,\n          entryPath,\n        );\n\n        await mkdir(dirname(workspacePath), { recursive: true });\n        const temporaryWorkspacePath = `${workspacePath}.${process.pid}.${Date.now()}.tmp`;\n\n        try {\n          await writeFile(temporaryWorkspacePath, content);\n          await rename(temporaryWorkspacePath, workspacePath);\n        } finally {\n          await rm(temporaryWorkspacePath, { force: true }).catch(\n            () => undefined,\n          );\n        }\n        await upsertOverlay({\n          archiveKey: this.#archiveKey,\n          archivePath: this.#archivePath,\n          entryPath,\n          kind: \"file\",\n          workspacePath,\n        });\n        this.#entrySourceByPath?.set(entryPath, {\n          kind: \"workspace\",\n          path: workspacePath,\n        });\n        if (source.kind === \"workspace\" && source.path !== workspacePath) {\n          await rm(source.path, { force: true }).catch(() => undefined);\n        }\n        this.#session?.modifyEntry(entryPath);\n      });\n    });\n  }\n\n  #toEntryPath(path: string): string {\n    const resolvedPath = resolve(path);\n    const rootPrefix = this.#archivePath.endsWith(\"/\")\n      ? this.#archivePath\n      : `${this.#archivePath}/`;\n\n    if (resolvedPath.startsWith(rootPrefix)) {\n      return normalizeEntryPath(resolvedPath.slice(rootPrefix.length));\n    }\n\n    return normalizeEntryPath(path);\n  }\n\n  async #listArchiveEntries(): Promise<readonly string[]> {\n    return (await this.#getArchiveReader()).listEntries();\n  }\n\n  async #readArchiveEntry(entryPath: string): Promise<Buffer | undefined> {\n    return await (await this.#getArchiveReader()).readEntry(entryPath);\n  }\n\n  async #getArchiveReader(): Promise<WikgArchiveReader> {\n    this.#archiveReader ??= WikgArchiveReader.open(this.#archivePath);\n    return await this.#archiveReader;\n  }\n\n  async #getEntrySources(): Promise<\n    Map<\n      string,\n      | { readonly kind: \"archive\" }\n      | { readonly kind: \"deleted\" }\n      | { readonly kind: \"workspace\"; readonly path: string }\n    >\n  > {\n    if (this.#entrySourceByPath !== undefined) {\n      return this.#entrySourceByPath;\n    }\n\n    const entries = new Map<\n      string,\n      | { readonly kind: \"archive\" }\n      | { readonly kind: \"deleted\" }\n      | { readonly kind: \"workspace\"; readonly path: string }\n    >();\n\n    for (const entryPath of await this.#listArchiveEntries()) {\n      entries.set(entryPath, { kind: \"archive\" });\n    }\n    for (const overlay of await listOverlays(this.#archiveKey)) {\n      if (overlay.kind === \"deleted\") {\n        entries.set(overlay.entryPath, { kind: \"deleted\" });\n      } else if (overlay.workspacePath !== undefined) {\n        entries.set(overlay.entryPath, {\n          kind: \"workspace\",\n          path: overlay.workspacePath,\n        });\n      }\n    }\n\n    this.#entrySourceByPath = entries;\n    return entries;\n  }\n\n  async #listDirectoryEntryPaths(\n    prefix: string,\n  ): Promise<\n    Array<\n      readonly [\n        string,\n        (\n          | { readonly kind: \"archive\" }\n          | { readonly kind: \"workspace\"; readonly path: string }\n        ),\n      ]\n    >\n  > {\n    const entries: Array<\n      readonly [\n        string,\n        (\n          | { readonly kind: \"archive\" }\n          | { readonly kind: \"workspace\"; readonly path: string }\n        ),\n      ]\n    > = [];\n\n    for (const [entryPath, source] of await this.#getEntrySources()) {\n      if (source.kind === \"deleted\" || !entryPath.startsWith(prefix)) {\n        continue;\n      }\n\n      entries.push([entryPath, source]);\n    }\n\n    return entries.sort(([left], [right]) => left.localeCompare(right));\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/storage/wikg/wikg-coordinator/flusher.d.ts

@@ -0,0 +1,4 @@
+declare function tryStartWikgFlusher(archivePath?: string): Promise<void>;
+declare function flushArchiveOverlays(archiveKey: string, requestedEntryPaths?: ReadonlySet<string>): Promise<void>;
+
+export { flushArchiveOverlays, tryStartWikgFlusher };

package/dist/storage/wikg/wikg-coordinator/flusher.js

@@ -0,0 +1,115 @@
+import { mkdir, mkdtemp, rename, rm } from "fs/promises";
+import { tmpdir } from "os";
+import { basename, dirname, join, resolve } from "path";
+import { writeWikgArchiveWithOverlays } from "../archive/index.js";
+import { createArchiveKey } from "./archive-key.js";
+import {
+  DATABASE_ENTRY_PATH,
+  SEARCH_INDEX_DATABASE_ENTRY_PATH
+} from "./constants.js";
+import {
+  acquireArchiveCommitLock,
+  acquireEntryLock,
+  waitForSqliteLeasesToDrain
+} from "./locks.js";
+import {
+  deleteOverlay,
+  listOverlays,
+  resolveArchivePathFromKey,
+  toArchiveOverlay
+} from "./overlays.js";
+import { cleanupStaleState, getString, withStateDatabase } from "./state.js";
+async function tryStartWikgFlusher(archivePath) {
+  if (archivePath !== void 0) {
+    await flushArchiveOverlays(createArchiveKey(resolve(archivePath)));
+    return;
+  }
+  const archiveKeys = await withStateDatabase(async (state) => {
+    await cleanupStaleState(state);
+    return await state.queryAll(
+      `
+SELECT DISTINCT archive_key
+FROM entry_overlays
+ORDER BY archive_key
+`,
+      void 0,
+      (row) => getString(row, "archive_key")
+    );
+  });
+  for (const archiveKey of archiveKeys) {
+    await flushArchiveOverlays(archiveKey);
+  }
+}
+async function flushArchiveOverlays(archiveKey, requestedEntryPaths) {
+  const overlays = (await listOverlays(archiveKey)).filter(
+    (overlay) => requestedEntryPaths === void 0 || requestedEntryPaths.has(overlay.entryPath)
+  );
+  const archivePath = await resolveArchivePathFromKey(archiveKey);
+  if (overlays.length === 0 || archivePath === void 0) {
+    return;
+  }
+  const entryPaths = overlays.map((overlay) => overlay.entryPath).sort((left, right) => left.localeCompare(right));
+  const lockedEntryPaths = new Set(entryPaths);
+  const releaseLocks = [];
+  try {
+    for (const entryPath of entryPaths) {
+      releaseLocks.push(await acquireEntryLock(archiveKey, entryPath, "write"));
+    }
+    for (const entryPath of entryPaths) {
+      releaseLocks.push(await acquireEntryLock(archiveKey, entryPath, "state"));
+    }
+    if (entryPaths.includes(DATABASE_ENTRY_PATH)) {
+      await waitForSqliteLeasesToDrain(archiveKey, DATABASE_ENTRY_PATH);
+    }
+    if (entryPaths.includes(SEARCH_INDEX_DATABASE_ENTRY_PATH)) {
+      await waitForSqliteLeasesToDrain(
+        archiveKey,
+        SEARCH_INDEX_DATABASE_ENTRY_PATH
+      );
+    }
+    const currentOverlays = (await listOverlays(archiveKey)).filter(
+      (overlay) => lockedEntryPaths.has(overlay.entryPath)
+    );
+    if (currentOverlays.length === 0) {
+      return;
+    }
+    const releaseCommit = await acquireArchiveCommitLock(archiveKey);
+    try {
+      const temporaryDirectoryPath = await mkdtemp(
+        join(tmpdir(), "wikigraph-flush-")
+      );
+      const temporaryArchivePath = join(
+        temporaryDirectoryPath,
+        basename(archivePath)
+      );
+      try {
+        await writeWikgArchiveWithOverlays(
+          archivePath,
+          temporaryArchivePath,
+          currentOverlays.map(toArchiveOverlay)
+        );
+        await mkdir(dirname(archivePath), { recursive: true });
+        await rename(temporaryArchivePath, archivePath);
+      } finally {
+        await rm(temporaryDirectoryPath, { force: true, recursive: true });
+      }
+    } finally {
+      await releaseCommit();
+    }
+    for (const overlay of currentOverlays) {
+      await deleteOverlay(archiveKey, overlay.entryPath);
+      if (overlay.workspacePath !== void 0) {
+        await rm(overlay.workspacePath, { force: true });
+      }
+    }
+  } finally {
+    for (const release of releaseLocks.reverse()) {
+      await release();
+    }
+  }
+}
+export {
+  flushArchiveOverlays,
+  tryStartWikgFlusher
+};
+//# sourceMappingURL=flusher.js.map

package/dist/storage/wikg/wikg-coordinator/flusher.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/storage/wikg/wikg-coordinator/flusher.ts"],"sourcesContent":["import { mkdir, mkdtemp, rename, rm } from \"fs/promises\";\nimport { tmpdir } from \"os\";\nimport { basename, dirname, join, resolve } from \"path\";\n\nimport { writeWikgArchiveWithOverlays } from \"../archive/index.js\";\n\nimport { createArchiveKey } from \"./archive-key.js\";\nimport {\n  DATABASE_ENTRY_PATH,\n  SEARCH_INDEX_DATABASE_ENTRY_PATH,\n} from \"./constants.js\";\nimport {\n  acquireArchiveCommitLock,\n  acquireEntryLock,\n  waitForSqliteLeasesToDrain,\n} from \"./locks.js\";\nimport {\n  deleteOverlay,\n  listOverlays,\n  resolveArchivePathFromKey,\n  toArchiveOverlay,\n} from \"./overlays.js\";\nimport { cleanupStaleState, getString, withStateDatabase } from \"./state.js\";\n\nexport async function tryStartWikgFlusher(archivePath?: string): Promise<void> {\n  if (archivePath !== undefined) {\n    await flushArchiveOverlays(createArchiveKey(resolve(archivePath)));\n    return;\n  }\n\n  const archiveKeys = await withStateDatabase(async (state) => {\n    await cleanupStaleState(state);\n    return await state.queryAll(\n      `\nSELECT DISTINCT archive_key\nFROM entry_overlays\nORDER BY archive_key\n`,\n      undefined,\n      (row) => getString(row, \"archive_key\"),\n    );\n  });\n\n  for (const archiveKey of archiveKeys) {\n    await flushArchiveOverlays(archiveKey);\n  }\n}\n\nexport async function flushArchiveOverlays(\n  archiveKey: string,\n  requestedEntryPaths?: ReadonlySet<string>,\n): Promise<void> {\n  const overlays = (await listOverlays(archiveKey)).filter(\n    (overlay) =>\n      requestedEntryPaths === undefined ||\n      requestedEntryPaths.has(overlay.entryPath),\n  );\n  const archivePath = await resolveArchivePathFromKey(archiveKey);\n\n  if (overlays.length === 0 || archivePath === undefined) {\n    return;\n  }\n\n  const entryPaths = overlays\n    .map((overlay) => overlay.entryPath)\n    .sort((left, right) => left.localeCompare(right));\n  const lockedEntryPaths = new Set(entryPaths);\n  const releaseLocks: Array<() => Promise<void>> = [];\n\n  try {\n    for (const entryPath of entryPaths) {\n      releaseLocks.push(await acquireEntryLock(archiveKey, entryPath, \"write\"));\n    }\n    for (const entryPath of entryPaths) {\n      releaseLocks.push(await acquireEntryLock(archiveKey, entryPath, \"state\"));\n    }\n\n    if (entryPaths.includes(DATABASE_ENTRY_PATH)) {\n      await waitForSqliteLeasesToDrain(archiveKey, DATABASE_ENTRY_PATH);\n    }\n    if (entryPaths.includes(SEARCH_INDEX_DATABASE_ENTRY_PATH)) {\n      await waitForSqliteLeasesToDrain(\n        archiveKey,\n        SEARCH_INDEX_DATABASE_ENTRY_PATH,\n      );\n    }\n\n    const currentOverlays = (await listOverlays(archiveKey)).filter((overlay) =>\n      lockedEntryPaths.has(overlay.entryPath),\n    );\n\n    if (currentOverlays.length === 0) {\n      return;\n    }\n\n    const releaseCommit = await acquireArchiveCommitLock(archiveKey);\n\n    try {\n      const temporaryDirectoryPath = await mkdtemp(\n        join(tmpdir(), \"wikigraph-flush-\"),\n      );\n      const temporaryArchivePath = join(\n        temporaryDirectoryPath,\n        basename(archivePath),\n      );\n\n      try {\n        await writeWikgArchiveWithOverlays(\n          archivePath,\n          temporaryArchivePath,\n          currentOverlays.map(toArchiveOverlay),\n        );\n        await mkdir(dirname(archivePath), { recursive: true });\n        await rename(temporaryArchivePath, archivePath);\n      } finally {\n        await rm(temporaryDirectoryPath, { force: true, recursive: true });\n      }\n    } finally {\n      await releaseCommit();\n    }\n\n    for (const overlay of currentOverlays) {\n      await deleteOverlay(archiveKey, overlay.entryPath);\n      if (overlay.workspacePath !== undefined) {\n        await rm(overlay.workspacePath, { force: true });\n      }\n    }\n  } finally {\n    for (const release of releaseLocks.reverse()) {\n      await release();\n    }\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/storage/wikg/wikg-coordinator/gc.d.ts

@@ -0,0 +1,5 @@
+import { GcContext, GcJobResult } from '../../../runtime/gc/types.js';
+
+declare function runWikgCoordinatorGc(context: GcContext): Promise<GcJobResult>;
+
+export { runWikgCoordinatorGc };