@vimhead.dev/norn-cli 0.1.0-tip.35390859630.1 → 0.1.0-tip.35436871363.1

package/dist/resources.js

@@ -1,100 +0,0 @@
-// ../core/src/atomic-files.ts
-import { randomUUID } from "node:crypto";
-import { chmod, mkdir, rename, rm, stat, writeFile } from "node:fs/promises";
-import { dirname } from "node:path";
-
-// ../core/src/errors.ts
-function isNodeError(error) {
-  return error instanceof Error && "code" in error;
-}
-
-// ../core/src/atomic-files.ts
-async function writeJsonAtomically(path, value) {
-  await writeTextAtomically(path, `${JSON.stringify(value, null, 2)}
-`);
-}
-async function writeTextAtomically(path, content) {
-  await mkdir(dirname(path), { recursive: true });
-  let existingMode;
-  try {
-    existingMode = (await stat(path)).mode & 511;
-  } catch (error) {
-    if (!isNodeError(error) || error.code !== "ENOENT") throw error;
-  }
-  const tmpPath = `${path}.${randomUUID()}.tmp`;
-  try {
-    await writeFile(tmpPath, content, { encoding: "utf8", mode: existingMode });
-    if (existingMode !== void 0) await chmod(tmpPath, existingMode);
-    await rename(tmpPath, path);
-  } catch (error) {
-    await rm(tmpPath, { force: true }).catch(() => void 0);
-    throw error;
-  }
-}
-
-// src/resources.ts
-import { createRunFileCoordinator } from "@vimhead.dev/norn/files";
-import { jsonValueSchema } from "@vimhead.dev/norn/schema";
-import { mkdir as mkdir2, readFile } from "node:fs/promises";
-import { join, resolve } from "node:path";
-import { isDeepStrictEqual } from "node:util";
-import { Type } from "typebox";
-import { Value } from "typebox/value";
-var definitionSchema = Type.Object({ name: Type.String(), kind: Type.String({ minLength: 1 }), configuration: jsonValueSchema }, { additionalProperties: false });
-var recordSchema = Type.Object({ ...definitionSchema.properties, isInitialized: Type.Boolean() }, { additionalProperties: false });
-var NornRunResources = class _NornRunResources {
-  constructor(runRoot) {
-    this.runRoot = runRoot;
-    this.files = createRunFileCoordinator(runRoot);
-  }
-  runRoot;
-  files;
-  entries = /* @__PURE__ */ new Map();
-  static async initialize(runRoot) {
-    const resources = new _NornRunResources(resolve(runRoot));
-    await mkdir2(join(resources.runRoot, "current", "resources"), { recursive: true });
-    return resources;
-  }
-  async ensure(definition) {
-    if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(definition.name)) throw new Error(`Invalid resource name: ${definition.name}`);
-    const identity = structuredClone(Value.Parse(definitionSchema, { name: definition.name, kind: definition.kind, configuration: definition.configuration }));
-    const existing = this.entries.get(definition.name);
-    if (existing) {
-      if (!isDeepStrictEqual(existing.definition, identity)) throw new Error(`Incompatible resource definition: ${definition.name}`);
-      return existing.value;
-    }
-    const value = this.initializeResource(definition, identity);
-    const entry = { definition: identity, value };
-    this.entries.set(definition.name, entry);
-    try {
-      return await value;
-    } catch (error) {
-      if (this.entries.get(definition.name) === entry) this.entries.delete(definition.name);
-      throw error;
-    }
-  }
-  async initializeResource(definition, identity) {
-    const directory = join(this.runRoot, "current", "resources", definition.name);
-    await mkdir2(directory, { recursive: true });
-    return this.files.withExclusiveLock(join(directory, "definition.json"), async (path) => {
-      let stored;
-      try {
-        stored = Value.Parse(recordSchema, JSON.parse(await readFile(path, "utf8")));
-      } catch (error) {
-        if (!isNodeError(error) || error.code !== "ENOENT") throw error;
-      }
-      if (stored) {
-        const { isInitialized: _isInitialized, ...storedIdentity } = stored;
-        if (!isDeepStrictEqual(storedIdentity, identity)) throw new Error(`Incompatible resource definition: ${definition.name}`);
-      } else {
-        await writeJsonAtomically(path, { ...identity, isInitialized: false });
-      }
-      const value = await definition.initialize({ directory, files: this.files, mode: stored?.isInitialized ? "open" : "create" });
-      if (!stored?.isInitialized) await writeJsonAtomically(path, { ...identity, isInitialized: true });
-      return value;
-    });
-  }
-};
-export {
-  NornRunResources
-};