@astrale-os/sdk 0.5.0-beta.13 → 0.5.0-beta.131

package/dist/tooling/linter/policy/configuration.js

@@ -0,0 +1,149 @@
+import { lstat, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { LinterToolError } from '../diagnostics/index.js';
+import { compileDomainPolicy } from './compile.js';
+import { domainPolicySource } from './generated.js';
+export const DOMAIN_LINT_CONFIG = 'astrale.lint.json';
+const MAX_CONFIG_BYTES = 64 * 1024;
+const MAX_REASON_BYTES = 240;
+const SOURCE_PATH = /^[a-z][a-z0-9-]*\/$/;
+const ALIAS = /^#[a-z][a-z0-9-]*$/;
+export async function compileProjectDomainPolicy(root, signal) {
+    return (await compileProjectDomainLint(root, signal)).policy;
+}
+export async function compileProjectDomainLint(root, signal) {
+    const configuration = await readDomainLintConfiguration(root, signal);
+    const policy = compileDomainPolicy(configureDomainPolicySource(domainPolicySource, configuration));
+    return Object.freeze({
+        policy,
+        disabled: admitDisabledRules(policy, configuration.disabledRules ?? {}),
+    });
+}
+export function configureDomainPolicySource(source, configuration) {
+    const configuredLayers = configuration.layers ?? {};
+    const knownLayers = new Set(source.layers.map(({ id }) => id));
+    for (const [id, configured] of Object.entries(configuredLayers)) {
+        if (!knownLayers.has(id))
+            invalid(`Unknown Domain lint layer ${id}.`);
+        if (!record(configured))
+            invalid(`Domain lint layer ${id} must be an object.`);
+        const fields = Object.keys(configured);
+        const unknown = fields.filter((field) => field !== 'sourcePath' && field !== 'alias');
+        if (unknown.length > 0) {
+            invalid(`Domain lint layer ${id} has unknown fields: ${unknown.join(', ')}.`);
+        }
+        if (fields.length === 0)
+            invalid(`Domain lint layer ${id} must configure a sourcePath or alias.`);
+        const sourcePath = configured.sourcePath;
+        if (sourcePath !== undefined &&
+            (typeof sourcePath !== 'string' || !SOURCE_PATH.test(sourcePath))) {
+            invalid(`Domain lint layer ${id} sourcePath must be a root directory ending in '/'.`);
+        }
+        const alias = configured.alias;
+        if (alias !== undefined && (typeof alias !== 'string' || !ALIAS.test(alias))) {
+            invalid(`Domain lint layer ${id} alias must be a root # alias without a wildcard.`);
+        }
+    }
+    const layers = source.layers.map((layer) => {
+        const sourcePath = configuredLayers[layer.id]?.sourcePath ?? layer.sourcePath;
+        return Object.freeze({ ...layer, sourcePath });
+    });
+    const sourcePaths = new Map(layers.map(({ id, sourcePath }) => [id, sourcePath]));
+    const aliases = source.aliases.map((alias) => {
+        const configuredPrefix = configuredLayers[alias.layer]?.alias;
+        const specifier = configuredPrefix === undefined
+            ? alias.specifier
+            : alias.kind === 'facade'
+                ? configuredPrefix
+                : `${configuredPrefix}/*`;
+        const sourcePath = sourcePaths.get(alias.layer);
+        const target = alias.kind === 'facade' ? `./${sourcePath}index.ts` : `./${sourcePath}*/index.ts`;
+        return Object.freeze({
+            ...alias,
+            specifier,
+            typescriptTarget: target,
+            packageTarget: target,
+        });
+    });
+    return Object.freeze({
+        ...source,
+        layers: Object.freeze(layers),
+        aliases: Object.freeze(aliases),
+    });
+}
+async function readDomainLintConfiguration(root, signal) {
+    ensureActive(signal);
+    const path = join(root, DOMAIN_LINT_CONFIG);
+    let metadata;
+    try {
+        metadata = await lstat(path);
+    }
+    catch (cause) {
+        if (cause.code === 'ENOENT')
+            return Object.freeze({});
+        invalid(`Cannot inspect Domain lint configuration ${path}.`, cause);
+    }
+    if (metadata.isSymbolicLink() || !metadata.isFile()) {
+        invalid(`Domain lint configuration must be a regular file: ${path}.`);
+    }
+    if (metadata.size > MAX_CONFIG_BYTES) {
+        invalid(`Domain lint configuration ${path} is ${metadata.size} bytes; maximum is ${MAX_CONFIG_BYTES}.`);
+    }
+    ensureActive(signal);
+    let value;
+    try {
+        const bytes = await readFile(path);
+        const text = new TextDecoder('utf-8', { fatal: true, ignoreBOM: false }).decode(bytes);
+        value = JSON.parse(text);
+    }
+    catch (cause) {
+        invalid(`Cannot parse Domain lint configuration ${path}.`, cause);
+    }
+    if (!record(value))
+        invalid('Domain lint configuration must be an object.');
+    const unknown = Object.keys(value).filter((field) => field !== 'layers' && field !== 'disabledRules');
+    if (unknown.length > 0) {
+        invalid(`Domain lint configuration has unknown fields: ${unknown.join(', ')}.`);
+    }
+    if (value.layers !== undefined && !record(value.layers)) {
+        invalid('Domain lint configuration layers must be an object.');
+    }
+    if (value.disabledRules !== undefined && !record(value.disabledRules)) {
+        invalid('Domain lint configuration disabledRules must be an object.');
+    }
+    return value;
+}
+function admitDisabledRules(policy, input) {
+    const reasons = new Map();
+    for (const [ruleId, value] of Object.entries(input)) {
+        if (!policy.catalog.get(ruleId))
+            invalid(`Disabled Domain lint rule ${ruleId} is unknown.`);
+        if (typeof value !== 'string') {
+            invalid(`Disabled Domain lint rule ${ruleId} reason must be a string.`);
+        }
+        const reason = value.trim();
+        const bytes = Buffer.byteLength(reason, 'utf8');
+        if (!reason || bytes > MAX_REASON_BYTES) {
+            invalid(`Disabled Domain lint rule ${ruleId} reason must contain 1-${MAX_REASON_BYTES} bytes.`);
+        }
+        reasons.set(ruleId, reason);
+    }
+    return Object.freeze(policy.catalog.rules.flatMap(({ id }) => {
+        const reason = reasons.get(id);
+        return reason === undefined ? [] : [Object.freeze({ ruleId: id, reason })];
+    }));
+}
+function ensureActive(signal) {
+    if (signal?.aborted) {
+        throw new LinterToolError('Domain lint was cancelled.', {
+            code: 'LINTER_CANCELLED',
+            cause: signal.reason,
+        });
+    }
+}
+function invalid(message, cause) {
+    throw new LinterToolError(message, { code: 'LINTER_PROJECT_INVALID', cause });
+}
+function record(value) {
+    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}

package/dist/tooling/linter/policy/generated.d.ts

@@ -0,0 +1,4 @@
+import type { DomainPolicySource } from './index.js';
+/** Generated from the validated Domain knowledge catalog. Regenerate with pnpm sync:linter-policy. */
+export declare const domainPolicyDigest: string;
+export declare const domainPolicySource: DomainPolicySource;