@nubbin/store-fs 0.1.0-rc.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jesse Wheeler
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+import { ArtifactStore } from '@nubbin/core';
+
+/**
+ * One pointer file per route, one file per artifact, and nothing else. No aggregate document
+ * exists, so two publishes to different routes cannot lose each other's write.
+ */
+declare function createFsArtifactStore(root: string): ArtifactStore;
+
+export { createFsArtifactStore };

package/dist/index.js

@@ -0,0 +1,109 @@
+// src/artifactPath.ts
+import { join } from "path";
+function artifactPath(root, hash) {
+  return join(root, "artifacts", `${hash}.json`);
+}
+
+// src/fsManifest.ts
+import { readdir } from "fs/promises";
+import { join as join2 } from "path";
+
+// src/readJsonOrNull.ts
+import { readFile } from "fs/promises";
+async function readJsonOrNull(filePath) {
+  try {
+    return JSON.parse(await readFile(filePath, "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+
+// src/fsManifest.ts
+async function fsManifest(root) {
+  const directory = join2(root, "routes");
+  let entries;
+  try {
+    entries = await readdir(directory);
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+    entries = [];
+  }
+  const read = entries.map((entry) => readJsonOrNull(join2(directory, entry)));
+  const routes = (await Promise.all(read)).filter((pointer) => pointer !== null);
+  return { routes, generatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+}
+
+// src/fsPublish.ts
+import { parseMatchKind } from "@nubbin/core";
+
+// src/pointerPath.ts
+import { join as join3 } from "path";
+
+// src/encodeRouteKey.ts
+function encodeRouteKey(route) {
+  return encodeURIComponent(route);
+}
+
+// src/pointerPath.ts
+function pointerPath(root, route) {
+  return join3(root, "routes", `${encodeRouteKey(route)}.json`);
+}
+
+// src/writeJsonAtomic.ts
+import { mkdir, rename, writeFile } from "fs/promises";
+import { dirname } from "path";
+async function writeJsonAtomic(filePath, value) {
+  await mkdir(dirname(filePath), { recursive: true });
+  const temp = `${filePath}.${process.pid}.tmp`;
+  await writeFile(temp, JSON.stringify(value, null, 2));
+  await rename(temp, filePath);
+}
+
+// src/fsPublish.ts
+async function fsPublish(root, route, hash) {
+  if (!await readJsonOrNull(artifactPath(root, hash))) {
+    throw new Error(`cannot publish ${route}: artifact ${hash} is not in the store`);
+  }
+  const pointer = {
+    route,
+    matchKind: parseMatchKind(route),
+    hash,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await writeJsonAtomic(pointerPath(root, route), pointer);
+}
+
+// src/fsUnpublish.ts
+import { rm } from "fs/promises";
+async function fsUnpublish(root, route) {
+  await rm(pointerPath(root, route), { force: true });
+}
+
+// src/fsWriteArtifact.ts
+async function fsWriteArtifact(root, artifact) {
+  const path = artifactPath(root, artifact.hash);
+  if (await readJsonOrNull(path)) {
+    return;
+  }
+  await writeJsonAtomic(path, artifact);
+}
+
+// src/createFsArtifactStore.ts
+function createFsArtifactStore(root) {
+  return {
+    read: (hash) => readJsonOrNull(artifactPath(root, hash)),
+    write: (artifact) => fsWriteArtifact(root, artifact),
+    pointer: (route) => readJsonOrNull(pointerPath(root, route)),
+    manifest: () => fsManifest(root),
+    publish: (route, hash) => fsPublish(root, route, hash),
+    unpublish: (route) => fsUnpublish(root, route)
+  };
+}
+export {
+  createFsArtifactStore
+};

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@nubbin/store-fs",
+  "version": "0.1.0-rc.0",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@nubbin/core": "0.1.0-rc.0"
+  },
+  "devDependencies": {
+    "@types/node": "25.9.2",
+    "tsup": "8.5.1",
+    "typescript": "6.0.3",
+    "vitest": "4.1.10"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
+}