@loomstack/verifier 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+import { VerifyResult } from '@loomstack/core';
+
+interface VerifyOptions {
+    feature?: string;
+    generated?: boolean;
+}
+declare function verifyProject(root: string, options?: VerifyOptions): VerifyResult;
+
+export { type VerifyOptions, verifyProject };

package/dist/index.js

@@ -0,0 +1,155 @@
+// src/index.ts
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import { join, relative } from "path";
+import { frameworkError, scanProject, toProjectPath } from "@loomstack/core";
+import { GENERATED_SOURCE_MARKER, generatedManifest, readGeneratedManifest, renderGeneratedFiles, sha256 } from "@loomstack/generator";
+function filesRecursively(directory) {
+  if (!existsSync(directory)) return [];
+  return readdirSync(directory).sort().flatMap((name) => {
+    const path = join(directory, name);
+    return statSync(path).isDirectory() ? filesRecursively(path) : [path];
+  });
+}
+function belongsToScope(error, feature) {
+  if (!feature || !error.file) return true;
+  return error.file.startsWith(`features/${feature}/`) || error.relatedFiles?.some((file) => file.startsWith(`features/${feature}/`)) === true;
+}
+function contractErrors(feature) {
+  const errors = [];
+  const actions = new Set(feature.actions.map((item) => item.name));
+  const declaredActions = new Set(feature.manifest.actions);
+  for (const name of [...declaredActions].sort()) {
+    if (!actions.has(name)) errors.push(frameworkError("loomstack1003", { message: `Manifest action "${name}" is not exported.`, file: feature.manifestPath }));
+  }
+  for (const action of feature.actions) {
+    if (!declaredActions.has(action.name)) errors.push(frameworkError("loomstack1004", { message: `Exported action "${action.name}" is missing from feature.yaml.`, file: action.file, relatedFiles: [feature.manifestPath] }));
+  }
+  const queries = new Set(feature.queries.map((item) => item.name));
+  const declaredQueries = new Set(feature.manifest.queries);
+  for (const name of [...declaredQueries].sort()) {
+    if (!queries.has(name)) errors.push(frameworkError("loomstack1007", { message: `Manifest query "${name}" is not exported.`, file: feature.manifestPath }));
+  }
+  for (const query of feature.queries) {
+    if (!declaredQueries.has(query.name)) errors.push(frameworkError("loomstack1008", { message: `Exported query "${query.name}" is missing from feature.yaml.`, file: query.file, relatedFiles: [feature.manifestPath] }));
+  }
+  const views = new Set(feature.views.map((item) => item.name));
+  for (const route of feature.manifest.routes) {
+    if (!views.has(route.view)) errors.push(frameworkError("loomstack1009", { message: `Route "${route.id}" references missing view "${route.view}".`, file: feature.manifestPath }));
+  }
+  const schemas = new Set(feature.schemas.map((item) => item.name));
+  for (const entity of feature.manifest.entities) {
+    if (!schemas.has(entity)) errors.push(frameworkError("loomstack1010", { message: `Manifest entity "${entity}" is not exported by model.schema.ts.`, file: feature.manifestPath }));
+  }
+  return errors;
+}
+function duplicateOperationErrors(project) {
+  const errors = [];
+  for (const key of ["actions", "queries"]) {
+    const owners = /* @__PURE__ */ new Map();
+    for (const feature of project.features) {
+      for (const item of feature[key]) {
+        const owner = owners.get(item.name);
+        if (owner) {
+          errors.push(frameworkError(key === "actions" ? "loomstack1004" : "loomstack1008", {
+            message: `Duplicate ${key.slice(0, -1)} name "${item.name}" is exported by ${owner} and ${feature.id}.`,
+            file: item.file
+          }));
+        } else owners.set(item.name, feature.id);
+      }
+    }
+  }
+  return errors;
+}
+function boundaryErrors(project, scope) {
+  const errors = [];
+  const features = scope ? project.features.filter((feature) => feature.id === scope) : project.features;
+  for (const feature of features) {
+    const files = filesRecursively(join(project.root, feature.directory)).filter((path) => /\.(ts|tsx)$/.test(path));
+    for (const absolute of files) {
+      const file = toProjectPath(relative(project.root, absolute));
+      const source = readFileSync(absolute, "utf8");
+      const imports = [...source.matchAll(/(?:from\s*|import\s*)["']([^"']+)["']/g)].map((match) => match[1] ?? "");
+      const isUi = file.includes("/ui/");
+      if (isUi && imports.some((specifier) => /(^|[\/@.-])(db|database|postgres)([\/@.-]|$)/i.test(specifier))) {
+        errors.push(frameworkError("loomstack2001", { file }));
+      }
+      if (isUi && /\bfetch\s*\(/.test(source)) errors.push(frameworkError("loomstack2002", { file }));
+      if ((file.includes("/actions/") || file.includes("/queries/") || isUi) && imports.some((specifier) => specifier === "koa" || specifier.startsWith("@koa/"))) {
+        errors.push(frameworkError("loomstack2003", { file }));
+      }
+    }
+  }
+  return errors;
+}
+function generatedErrors(project) {
+  const errors = [];
+  let expected;
+  try {
+    expected = renderGeneratedFiles(project);
+  } catch {
+    return errors;
+  }
+  const expectedManifest = generatedManifest(expected);
+  const recorded = readGeneratedManifest(project);
+  const manifestPath = `${project.config.generatedDir}/generated-files.json`;
+  if (!recorded || recorded.generatedBy !== "loomstack" || recorded.doNotEdit !== true || !Array.isArray(recorded.files)) {
+    return [frameworkError("loomstack4002", { message: `${manifestPath} is missing or invalid.`, file: manifestPath })];
+  }
+  const records = new Map(recorded.files.map((item) => [item.path, item.sha256]));
+  for (const [path, expectedContent] of Object.entries(expected)) {
+    const absolute = join(project.root, path);
+    if (!existsSync(absolute)) {
+      errors.push(frameworkError("loomstack4002", { message: `Generated file is missing: ${path}.`, file: path }));
+      continue;
+    }
+    const actualContent = readFileSync(absolute, "utf8");
+    const isSource = /\.(ts|tsx)$/.test(path);
+    let marked = false;
+    if (isSource) marked = actualContent.startsWith(GENERATED_SOURCE_MARKER);
+    else {
+      try {
+        const json = JSON.parse(actualContent);
+        marked = json.generatedBy === "loomstack" && json.doNotEdit === true;
+      } catch {
+        marked = false;
+      }
+    }
+    if (!marked) {
+      errors.push(frameworkError("loomstack4001", { message: `Generated marker is missing from ${path}.`, file: path }));
+      continue;
+    }
+    const actualHash = sha256(actualContent);
+    const recordedHash = records.get(path);
+    const expectedHash = sha256(expectedContent);
+    if (!recordedHash) {
+      errors.push(frameworkError("loomstack4002", { message: `${path} is not tracked in ${manifestPath}.`, file: path }));
+    } else if (actualHash !== recordedHash && actualHash !== expectedHash) {
+      errors.push(frameworkError("loomstack4001", { file: path }));
+    } else if (actualHash !== expectedHash || recordedHash !== expectedHash) {
+      errors.push(frameworkError("loomstack4002", { message: `${path} is stale.`, file: path }));
+    }
+  }
+  const expectedPaths = new Set(expectedManifest.files.map((item) => item.path));
+  for (const record of recorded.files) {
+    if (!expectedPaths.has(record.path)) errors.push(frameworkError("loomstack4002", { message: `Generated manifest tracks obsolete file ${record.path}.`, file: manifestPath, relatedFiles: [record.path] }));
+  }
+  return errors;
+}
+function verifyProject(root, options = {}) {
+  const scanned = scanProject(root);
+  const errors = scanned.errors.filter((error) => belongsToScope(error, options.feature));
+  if (!scanned.project) return { ok: false, errors, warnings: [] };
+  const selected = options.feature ? scanned.project.features.filter((feature) => feature.id === options.feature) : scanned.project.features;
+  if (options.feature && selected.length === 0) {
+    errors.push(frameworkError("loomstack1002", { message: `Unknown feature: ${options.feature}.`, file: `${scanned.project.config.featuresDir}/${options.feature}` }));
+  }
+  for (const feature of selected) errors.push(...contractErrors(feature));
+  errors.push(...duplicateOperationErrors(scanned.project).filter((error) => belongsToScope(error, options.feature)));
+  errors.push(...boundaryErrors(scanned.project, options.feature));
+  if (options.generated !== false) errors.push(...generatedErrors(scanned.project));
+  const unique = [...new Map(errors.map((error) => [`${error.code}:${error.file ?? ""}:${error.message}`, error])).values()].sort((a, b) => (a.file ?? "").localeCompare(b.file ?? "") || a.code.localeCompare(b.code));
+  return { ok: unique.length === 0, errors: unique, warnings: [] };
+}
+export {
+  verifyProject
+};

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@loomstack/verifier",
+  "version": "0.0.1",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@loomstack/core": "0.0.1",
+    "@loomstack/generator": "0.0.1"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "test": "vitest run"
+  }
+}