@azure-net/cli 5.1.1 → 6.0.0-next.2

package/src/utils/flattenConfig.js

@@ -0,0 +1,38 @@
+import ts from 'typescript';
+/** Flatten literal-only spreads without evaluating user configuration or duplicating effects. */
+export function flattenConfigLiterals(content) {
+    const source = ts.createSourceFile('azure-net.config.ts', content, ts.ScriptTarget.Latest, true);
+    const exported = source.statements.find(ts.isExportAssignment);
+    if (!exported)
+        return content;
+    const unwrap = (node) => (ts.isParenthesizedExpression(node) ? unwrap(node.expression) : node);
+    const root = unwrap(exported.expression);
+    if (!ts.isObjectLiteralExpression(root))
+        return content;
+    let changed = false;
+    const flatten = (object) => object.properties.flatMap((property) => {
+        if (ts.isSpreadAssignment(property)) {
+            const value = unwrap(property.expression);
+            if (ts.isObjectLiteralExpression(value) &&
+                value.properties.every((p) => !ts.isGetAccessorDeclaration(p) &&
+                    !ts.isSetAccessorDeclaration(p) &&
+                    !(p.name && p.name.getText(source).replace(/['"]/g, '') === '__proto__'))) {
+                changed = true;
+                return flatten(value);
+            }
+        }
+        return [property];
+    });
+    const properties = flatten(root);
+    if (!changed)
+        return content;
+    const names = properties
+        .filter((p) => p.name && !ts.isComputedPropertyName(p.name))
+        .map((p) => p.name.getText(source).replace(/['"]/g, ''));
+    // Duplicate literal keys can produce invalid TypeScript; retain the original spread semantics.
+    if (new Set(names).size !== names.length)
+        return content;
+    const updated = ts.factory.updateObjectLiteralExpression(root, properties);
+    const printed = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed }).printNode(ts.EmitHint.Expression, updated, source);
+    return content.slice(0, root.getStart(source)) + printed + content.slice(root.end);
+}

package/src/utils/legacyAliases.js

@@ -0,0 +1,75 @@
+import ts from 'typescript';
+export function mergeAliasesInSvelteConfig(content, aliases) {
+    const source = ts.createSourceFile('svelte.config.js', content, ts.ScriptTarget.Latest, true, ts.ScriptKind.JS);
+    function resolve(expression, seen = new Set()) {
+        if (ts.isObjectLiteralExpression(expression))
+            return expression;
+        if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isSatisfiesExpression(expression))
+            return resolve(expression.expression, seen);
+        if (ts.isIdentifier(expression) && !seen.has(expression.text)) {
+            seen.add(expression.text);
+            for (const statement of source.statements)
+                if (ts.isVariableStatement(statement)) {
+                    for (const declaration of statement.declarationList.declarations)
+                        if (ts.isIdentifier(declaration.name) && declaration.name.text === expression.text && declaration.initializer)
+                            return resolve(declaration.initializer, seen);
+                }
+        }
+        throw new Error('Cannot safely merge Svelte aliases: use an object literal or a local object variable for the config and kit.');
+    }
+    const exported = source.statements.find(ts.isExportAssignment);
+    if (!exported)
+        throw new Error('Cannot safely merge Svelte aliases: no default export found.');
+    const root = resolve(exported.expression);
+    const property = (object, name) => [...object.properties]
+        .reverse()
+        .find((entry) => entry.name && (ts.isIdentifier(entry.name) || ts.isStringLiteral(entry.name)) && entry.name.text === name);
+    const value = (entry) => {
+        if (ts.isPropertyAssignment(entry))
+            return entry.initializer;
+        if (ts.isShorthandPropertyAssignment(entry))
+            return entry.name;
+        throw new Error('Cannot safely merge Svelte aliases: unsupported property declaration.');
+    };
+    const insert = (object, text) => {
+        const last = object.properties.at(-1);
+        const comma = last && !object.properties.hasTrailingComma ? ',' : '';
+        // Insert the separator before any trailing line comment.
+        let next = content.slice(0, object.end - 1) + `\n${text}\n` + content.slice(object.end - 1);
+        if (last && comma)
+            next = next.slice(0, last.end) + comma + next.slice(last.end);
+        return next;
+    };
+    const entries = Object.entries(aliases)
+        .map(([key, target]) => `${JSON.stringify(key)}: ${JSON.stringify(target)}`)
+        .join(',\n');
+    const kit = property(root, 'kit');
+    if (!kit)
+        return insert(root, `kit: { alias: { ${entries} } }`);
+    const kitObject = resolve(value(kit));
+    const alias = property(kitObject, 'alias');
+    if (!alias)
+        return insert(kitObject, `alias: { ${entries} }`);
+    const expression = value(alias);
+    if (ts.isObjectLiteralExpression(expression)) {
+        const missing = Object.entries(aliases).filter(([key, target]) => {
+            const entry = property(expression, key);
+            if (!entry || !ts.isPropertyAssignment(entry) || !ts.isStringLiteral(entry.initializer) || entry.initializer.text !== target)
+                return true;
+            // Later spreads or computed keys can override an otherwise correct entry.
+            return expression.properties
+                .slice(expression.properties.indexOf(entry) + 1)
+                .some((later) => ts.isSpreadAssignment(later) || (later.name && ts.isComputedPropertyName(later.name)));
+        });
+        if (!missing.length)
+            return content;
+        if (missing.every(([key]) => !property(expression, key))) {
+            return insert(expression, missing.map(([key, target]) => `${JSON.stringify(key)}: ${JSON.stringify(target)}`).join(',\n'));
+        }
+    }
+    // Preserve every user expression, spread and comment; fixed architecture aliases win.
+    const replacement = `{ ...(${expression.getText(source)}), ${entries} }`;
+    if (ts.isShorthandPropertyAssignment(alias))
+        return content.slice(0, alias.getStart(source)) + `alias: ${replacement}` + content.slice(alias.end);
+    return content.slice(0, expression.getStart(source)) + replacement + content.slice(expression.end);
+}

package/src/utils/loadConfig.js

@@ -1,46 +1,82 @@
 import fs from 'node:fs/promises';
 import fsSync from 'node:fs';
 import path from 'node:path';
-const DEFAULT_CONFIG = {
-	contexts: [],
-	defaultContext: 'web'
-};
-function toObjectFromDefaultExport(content) {
-	const source = String(content ?? '').trim();
-	if (!source.length) return {};
-	const replacedExport = source.replace(/^\s*export\s+default\s+/m, 'return ');
-	if (replacedExport === source) return {};
-	const withSemicolon = /;\s*$/.test(replacedExport) ? replacedExport : `${replacedExport};`;
-	try {
-		return new Function(withSemicolon)() ?? {};
-	} catch {
-		return {};
-	}
-}
+import { createRequire } from 'node:module';
+import ts from 'typescript';
+import { flattenConfigLiterals } from './flattenConfig.js';
 export function resolveConfigFile(cwd = process.cwd()) {
-	const tsPath = path.join(cwd, 'azure-net.config.ts');
-	const jsPath = path.join(cwd, 'azure-net.config.js');
-	if (fsSync.existsSync(tsPath)) {
-		return { exists: true, filepath: tsPath, type: 'ts' };
-	}
-	if (fsSync.existsSync(jsPath)) {
-		return { exists: true, filepath: jsPath, type: 'js' };
-	}
-	return { exists: false, filepath: tsPath, type: 'ts' };
+    for (const type of ['ts', 'js']) {
+        const filepath = path.join(cwd, `azure-net.config.${type}`);
+        if (fsSync.existsSync(filepath))
+            return { exists: true, filepath, type };
+    }
+    return { exists: false, filepath: path.join(cwd, 'azure-net.config.ts'), type: 'ts' };
+}
+export async function loadUserConfig(cwd = process.cwd()) {
+    const { exists, filepath } = resolveConfigFile(cwd);
+    if (!exists)
+        return {};
+    try {
+        const source = await fs.readFile(filepath, 'utf8');
+        const result = ts.transpileModule(source, {
+            fileName: filepath,
+            reportDiagnostics: true,
+            compilerOptions: { target: ts.ScriptTarget.ES2022, module: ts.ModuleKind.CommonJS, esModuleInterop: true }
+        });
+        const errors = result.diagnostics?.filter((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error) ?? [];
+        if (errors.length)
+            throw new Error(errors.map((error) => ts.flattenDiagnosticMessageText(error.messageText, '\n')).join('\n'));
+        const module = { exports: {} };
+        new Function('module', 'exports', 'require', '__filename', '__dirname', result.outputText)(module, module.exports, createRequire(filepath), filepath, path.dirname(filepath));
+        const config = module.exports.default;
+        if (!config || typeof config !== 'object' || Array.isArray(config))
+            throw new Error('Expected a default-exported configuration object.');
+        const parsed = config;
+        if (parsed.presentationWorkspaces !== undefined &&
+            (!Array.isArray(parsed.presentationWorkspaces) ||
+                parsed.presentationWorkspaces.some((name) => typeof name !== 'string' || !/^[A-Za-z][A-Za-z0-9 _-]*$/.test(name.trim()))))
+            throw new Error('presentationWorkspaces must be an array of valid workspace names.');
+        if (parsed.runChecksBeforePush !== undefined && typeof parsed.runChecksBeforePush !== 'boolean')
+            throw new Error('runChecksBeforePush must be a boolean.');
+        return parsed;
+    }
+    catch (error) {
+        throw new Error(`Unable to load ${filepath}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+    }
 }
-export async function loadUserConfig() {
-	const { exists, filepath } = resolveConfigFile();
-	if (!exists) {
-		return { ...DEFAULT_CONFIG };
-	}
-	try {
-		const content = await fs.readFile(filepath, 'utf-8');
-		const parsed = toObjectFromDefaultExport(content);
-		if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
-			return { ...DEFAULT_CONFIG };
-		}
-		return { ...DEFAULT_CONFIG, ...parsed };
-	} catch {
-		return { ...DEFAULT_CONFIG };
-	}
+/** Add the default without rewriting or dropping legacy/user configuration. */
+export async function initializeConfigDefaults(cwd = process.cwd()) {
+    const existing = resolveConfigFile(cwd);
+    if (existing.exists) {
+        const original = await fs.readFile(existing.filepath, 'utf8');
+        const flattened = flattenConfigLiterals(original);
+        if (flattened !== original)
+            await fs.writeFile(existing.filepath, flattened);
+    }
+    const config = await loadUserConfig(cwd);
+    if (config.runChecksBeforePush !== undefined)
+        return;
+    const resolved = resolveConfigFile(cwd);
+    if (!resolved.exists) {
+        await fs.writeFile(resolved.filepath, 'export default {\n\trunChecksBeforePush: true\n};\n', { flag: 'wx' });
+        return;
+    }
+    const content = await fs.readFile(resolved.filepath, 'utf8');
+    const source = ts.createSourceFile(resolved.filepath, content, ts.ScriptTarget.Latest, true);
+    const exported = source.statements.find(ts.isExportAssignment);
+    if (!exported || exported.isExportEquals)
+        throw new Error(`Cannot initialize ${resolved.filepath}: expected a default export.`);
+    const expression = exported.expression;
+    let nextContent;
+    if (ts.isObjectLiteralExpression(expression)) {
+        const last = expression.properties.at(-1);
+        nextContent = content.slice(0, expression.end - 1) + '\n\trunChecksBeforePush: true\n' + content.slice(expression.end - 1);
+        if (last && !expression.properties.hasTrailingComma)
+            nextContent = nextContent.slice(0, last.end) + ',' + nextContent.slice(last.end);
+    }
+    else {
+        const replacement = `{ ...(${expression.getText(source)}), runChecksBeforePush: true }`;
+        nextContent = content.slice(0, expression.getStart(source)) + replacement + content.slice(expression.end);
+    }
+    await fs.writeFile(resolved.filepath, nextContent, 'utf8');
 }

package/src/utils/packageImports.js

@@ -0,0 +1,63 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { format } from 'prettier';
+export const PACKAGE_IMPORTS = Object.fromEntries(['Contexts', 'Presentation', 'Platform'].flatMap((name) => {
+    const key = '#' + name.toLowerCase(), root = './src/app/' + name;
+    return [
+        [key, root + '/index.ts'],
+        [key + '/*', { types: [root + '/*.ts', root + '/*/index.ts', root + '/*'], default: root + '/*' }]
+    ];
+}));
+export async function mergePackageImports(content) {
+    const json = JSON.parse(content);
+    if (!json || typeof json !== 'object' || Array.isArray(json))
+        throw new Error('Expected a package.json object');
+    if (json.imports !== undefined && (!json.imports || typeof json.imports !== 'object' || Array.isArray(json.imports)))
+        throw new Error('Expected package.json imports object');
+    const imports = { ...json.imports };
+    for (const [key, value] of Object.entries(PACKAGE_IMPORTS)) {
+        if (key in imports && JSON.stringify(imports[key]) !== JSON.stringify(value))
+            throw new Error(`Conflicting package import ${key}; review its target before initialization.`);
+        imports[key] = value;
+    }
+    return format(JSON.stringify({ ...json, imports }), { parser: 'json', useTabs: true });
+}
+export async function initializePackageImports() {
+    const file = path.resolve('package.json');
+    let content;
+    try {
+        content = await fs.readFile(file, 'utf8');
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+        content = '{}';
+    }
+    await fs.writeFile(file, await mergePackageImports(content));
+}
+export function resolvePackageImport(imports, specifier, root) {
+    const target = (v) => {
+        if (typeof v === 'string')
+            return v;
+        if (Array.isArray(v))
+            return v.map(target).find(Boolean);
+        if (v && typeof v === 'object') {
+            const obj = v;
+            return target(obj.default ?? obj.import ?? obj.types);
+        }
+    };
+    for (const key of Object.keys(imports).sort((a, b) => b.replace('*', '').length - a.replace('*', '').length)) {
+        const value = target(imports[key]);
+        if (!value?.startsWith('./'))
+            continue;
+        if (!key.includes('*')) {
+            if (key === specifier)
+                return path.resolve(root, value);
+            continue;
+        }
+        const [prefix, suffix = ''] = key.split('*');
+        if (specifier.startsWith(prefix) && specifier.endsWith(suffix))
+            return path.resolve(root, value.replace('*', specifier.slice(prefix.length, suffix ? -suffix.length : undefined)));
+    }
+    return null;
+}

package/src/utils/sharedFoundation.js

@@ -1,48 +1,42 @@
 import path from 'node:path';
-import { normalizeContexts } from '../init/initAliases.js';
-import { loadUserConfig, resolveConfigFile } from './loadConfig.js';
-export const SHARED_ESSENTIALS_DIR_NAME = 'essentials';
-const normalizeAlias = (value) => {
-	const raw = String(value ?? '').trim();
-	return raw.startsWith('$') ? raw : `$${raw}`;
+import { discoverContexts, getContextPath, getPlatformPath, SHARED_CONTEXT } from './architecture.js';
+import { resolveConfigFile } from './loadConfig.js';
+export const SHARED_ESSENTIALS_DIR_NAME = 'Platform';
+const constructNames = {
+    datasource: 'Datasource',
+    presenter: 'Presenter',
+    provider: 'DI',
+    response: 'Response',
+    schema: 'Schema'
 };
-const createMissingSharedAliasError = () =>
-	new Error(
-		'`sharedAlias` is missing in azure-net.config.ts/js. Add sharedAlias and make sure it points to one of `contexts`, for example: sharedAlias: "$shared-kernel".'
-	);
-export const getSharedState = async () => {
-	const config = await loadUserConfig();
-	const contexts = normalizeContexts(config.contexts);
-	const sharedAliasRaw = String(config.sharedAlias ?? '').trim();
-	if (!sharedAliasRaw.length) throw createMissingSharedAliasError();
-	const sharedAlias = normalizeAlias(sharedAliasRaw);
-	const sharedContext = contexts.find((context) => normalizeAlias(context.alias) === sharedAlias);
-	if (!sharedContext) {
-		throw new Error(
-			`sharedAlias "${sharedAlias}" does not point to any configured context. Add a context with alias "${sharedAlias}" in azure-net.config.ts/js.`
-		);
-	}
-	return {
-		contexts,
-		sharedAlias,
-		sharedContext
-	};
+export async function getSharedState() {
+    const names = await discoverContexts();
+    if (!names.includes(SHARED_CONTEXT))
+        names.push(SHARED_CONTEXT);
+    const contexts = names.sort().map((name) => ({ name, alias: `#contexts/${name}` }));
+    return { contexts, sharedAlias: '#platform', sharedContext: contexts.find((context) => context.name === SHARED_CONTEXT) };
+}
+export const hasSharedAliasConfig = async () => true;
+export const getSharedContextRootPath = (name = SHARED_CONTEXT) => getContextPath(name);
+export const getSharedEssentialsPath = (...compatibility) => {
+    void compatibility;
+    return getPlatformPath();
 };
-export const hasSharedAliasConfig = async () => {
-	const config = await loadUserConfig();
-	return String(config.sharedAlias ?? '').trim().length > 0;
+export const getFoundationRootPath = (...compatibility) => {
+    void compatibility;
+    return path.join(getPlatformPath(), 'Foundation');
+};
+export const getFoundationConstructPath = (name, construct) => path.join(getFoundationRootPath(name), constructNames[construct]);
+export const getFoundationConstructImportPath = (_alias, construct) => `#platform/Foundation/${constructNames[construct]}`;
+export const getLocalizationPath = (...compatibility) => {
+    void compatibility;
+    return path.join(getPlatformPath(), 'Bootstrap', 'Localization');
+};
+export const getLocalizationImportPath = (...compatibility) => {
+    void compatibility;
+    return '#platform/Bootstrap/Localization';
 };
-export const getSharedContextRootPath = (sharedContextName) => path.join(process.cwd(), 'src', 'app', sharedContextName);
-export const getSharedEssentialsPath = (sharedContextName) =>
-	path.join(getSharedContextRootPath(sharedContextName), SHARED_ESSENTIALS_DIR_NAME);
-export const getFoundationRootPath = (sharedContextName) =>
-	path.join(getSharedEssentialsPath(sharedContextName), 'foundation', 'constructs');
-export const getFoundationConstructPath = (sharedContextName, construct) => path.join(getFoundationRootPath(sharedContextName), construct);
-export const getFoundationConstructImportPath = (sharedAlias, construct) =>
-	`${sharedAlias}/${SHARED_ESSENTIALS_DIR_NAME}/foundation/constructs/${construct}`;
-export const getLocalizationPath = (sharedContextName) => path.join(getSharedEssentialsPath(sharedContextName), 'localization');
-export const getLocalizationImportPath = (sharedAlias) => `${sharedAlias}/${SHARED_ESSENTIALS_DIR_NAME}/localization`;
 export const getConfigFileLabel = () => {
-	const config = resolveConfigFile();
-	return config.exists ? path.basename(config.filepath) : 'azure-net.config.ts/js';
+    const config = resolveConfigFile();
+    return config.exists ? path.basename(config.filepath) : 'azure-net.config.ts/js';
 };