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

package/src/utils/viteConfig.js

@@ -0,0 +1,295 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import ts from 'typescript';
+import { format, resolveConfig } from 'prettier';
+import { mergeAliasesInSvelteConfig } from './legacyAliases.js';
+import { ARCHITECTURE_ALIASES } from './architecture.js';
+export const VITE_CONFIGS = ['vite.config.ts', 'vite.config.js', 'vite.config.mts', 'vite.config.mjs'];
+export const SVELTE_CONFIGS = ['svelte.config.js', 'svelte.config.ts', 'svelte.config.mjs'];
+const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+const parse = (text) => ts.createSourceFile('config.ts', text, ts.ScriptTarget.Latest, true);
+const name = (node) => node && (ts.isIdentifier(node) || ts.isStringLiteral(node)) ? node.text : undefined;
+function object(expression, source, seen = new Set()) {
+    if (ts.isObjectLiteralExpression(expression))
+        return expression;
+    if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isSatisfiesExpression(expression))
+        return object(expression.expression, source, 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 d of statement.declarationList.declarations)
+                    if (name(d.name) === expression.text && d.initializer)
+                        return object(d.initializer, source, seen);
+    }
+    throw new Error('Cannot safely edit dynamic SvelteKit options. Use an object literal or a local object variable in sveltekit().');
+}
+function kitCall(source) {
+    const names = new Set();
+    for (const s of source.statements)
+        if (ts.isImportDeclaration(s) && ts.isStringLiteral(s.moduleSpecifier) && s.moduleSpecifier.text === '@sveltejs/kit/vite') {
+            const b = s.importClause?.namedBindings;
+            if (b && ts.isNamedImports(b))
+                for (const e of b.elements)
+                    if ((e.propertyName?.text ?? e.name.text) === 'sveltekit')
+                        names.add(e.name.text);
+        }
+    const calls = [];
+    const visit = (n) => {
+        if (ts.isCallExpression(n) && ts.isIdentifier(n.expression) && names.has(n.expression.text))
+            calls.push(n);
+        ts.forEachChild(n, visit);
+    };
+    visit(source);
+    if (calls.length !== 1)
+        throw new Error('Expected exactly one imported sveltekit() call in vite.config. No files changed.');
+    return calls[0];
+}
+function modernOptions(input, source) {
+    const has = (obj, key) => obj.properties.some((p) => name(p.name) === key);
+    const nestedHas = (key, keys) => {
+        const property = input.properties.find((p) => name(p.name) === key);
+        if (!property || !ts.isPropertyAssignment(property))
+            return false;
+        const value = objectOrUndefined(property.initializer, source);
+        return value && keys.some((k) => has(value, k));
+    };
+    if (!['kit', 'vitePlugin', 'preloadStrategy'].some((k) => has(input, k)) &&
+        !nestedHas('files', ['lib']) &&
+        !nestedHas('experimental', ['handleRenderingErrors', 'instrumentation', 'tracing']) &&
+        !nestedHas('prerender', ['origin']) &&
+        !nestedHas('csrf', ['checkOrigin']))
+        return input.getText(source);
+    const print = (n) => printer.printNode(ts.EmitHint.Unspecified, n, source);
+    const props = [...input.properties];
+    const take = (items, key) => {
+        const found = items.findIndex((p) => name(p.name) === key);
+        if (found < 0)
+            return;
+        const p = items.splice(found, 1)[0];
+        if (!ts.isPropertyAssignment(p))
+            throw new Error(`Cannot safely convert option ${key}`);
+        return p.initializer;
+    };
+    const set = (items, key, value) => {
+        if (items.some((p) => name(p.name) === key))
+            throw new Error(`Conflicting SvelteKit option ${key}; resolve manually.`);
+        items.push(ts.factory.createPropertyAssignment(key, value));
+    };
+    const nested = (key, edit) => {
+        const value = take(props, key);
+        if (!value)
+            return;
+        const items = [...object(value, source).properties];
+        edit(items);
+        if (items.length)
+            set(props, key, ts.factory.createObjectLiteralExpression(items, true));
+    };
+    const oldKit = take(props, 'kit');
+    if (oldKit)
+        for (const p of object(oldKit, source).properties) {
+            if (props.some((existing) => name(existing.name) && name(existing.name) === name(p.name)))
+                throw new Error(`Conflicting option ${name(p.name)}`);
+            props.push(p);
+        }
+    const vitePlugin = take(props, 'vitePlugin');
+    if (vitePlugin)
+        for (const p of object(vitePlugin, source).properties) {
+            if (props.some((existing) => name(existing.name) && name(existing.name) === name(p.name)))
+                throw new Error(`Conflicting option ${name(p.name)}`);
+            props.push(p);
+        }
+    take(props, 'preloadStrategy');
+    nested('files', (items) => {
+        take(items, 'lib');
+    });
+    nested('experimental', (items) => {
+        take(items, 'handleRenderingErrors');
+        take(items, 'instrumentation');
+        const tracing = take(items, 'tracing');
+        if (tracing)
+            set(props, 'tracing', tracing);
+    });
+    let origin;
+    nested('prerender', (items) => {
+        origin = take(items, 'origin');
+    });
+    if (origin) {
+        const paths = take(props, 'paths');
+        const items = paths ? [...object(paths, source).properties] : [];
+        set(items, 'origin', origin);
+        set(props, 'paths', ts.factory.createObjectLiteralExpression(items, true));
+    }
+    nested('csrf', (items) => {
+        const check = take(items, 'checkOrigin');
+        if (!check)
+            return;
+        if (check.kind === ts.SyntaxKind.FalseKeyword) {
+            if (items.some((p) => name(p.name) === 'trustedOrigins'))
+                throw new Error('Resolve csrf.checkOrigin and trustedOrigins manually.');
+            set(items, 'trustedOrigins', ts.factory.createArrayLiteralExpression([ts.factory.createStringLiteral('*')]));
+        }
+        else if (check.kind !== ts.SyntaxKind.TrueKeyword)
+            throw new Error('Dynamic csrf.checkOrigin requires manual migration.');
+    });
+    return print(ts.factory.createObjectLiteralExpression(props, true));
+}
+/** Pure config edit; never evaluates a project's configuration. */
+export function mergeKitViteConfig(content, aliases, legacy) {
+    let source = parse(content);
+    const call = kitCall(source);
+    let options = call.arguments[0] ? object(call.arguments[0], source) : undefined;
+    let optionText = options ? modernOptions(options, source) : '{}';
+    if (legacy) {
+        if (options && options.properties.length)
+            throw new Error('Both Vite and legacy Svelte config contain options. Merge them with sv migrate sveltekit-3 first.');
+        const old = parse(legacy), exported = old.statements.find(ts.isExportAssignment);
+        if (!exported)
+            throw new Error('Legacy Svelte config has no default export.');
+        const root = object(exported.expression, old);
+        optionText = modernOptions(root, old);
+        const imports = old.statements.filter(ts.isImportDeclaration);
+        const bindings = (s) => {
+            const names = new Set();
+            for (const n of s.statements) {
+                if (ts.isImportDeclaration(n)) {
+                    if (n.importClause?.name)
+                        names.add(n.importClause.name.text);
+                    const b = n.importClause?.namedBindings;
+                    if (b && ts.isNamespaceImport(b))
+                        names.add(b.name.text);
+                    if (b && ts.isNamedImports(b))
+                        for (const e of b.elements)
+                            names.add(e.name.text);
+                }
+                if (ts.isVariableStatement(n))
+                    for (const d of n.declarationList.declarations)
+                        if (ts.isIdentifier(d.name))
+                            names.add(d.name.text);
+            }
+            return names;
+        };
+        const oldNames = bindings(old);
+        const currentNames = bindings(source);
+        for (const n of oldNames)
+            if (currentNames.has(n))
+                throw new Error(`Config binding collision: ${n}. Run sv migrate sveltekit-3 first.`);
+        const rootStatement = old.statements.find((s) => ts.isVariableStatement(s) &&
+            s.declarationList.declarations.some((d) => d.initializer && objectOrUndefined(d.initializer, old) === root));
+        if (rootStatement && ts.isVariableStatement(rootStatement) && rootStatement.declarationList.declarations.length !== 1)
+            throw new Error('Split legacy config variable declarations before migration.');
+        for (const statement of old.statements)
+            if (!ts.isImportDeclaration(statement) &&
+                !ts.isExportAssignment(statement) &&
+                statement !== rootStatement &&
+                !ts.isEmptyStatement(statement))
+                throw new Error('Complex legacy config: run sv migrate sveltekit-3 first.');
+        const importText = imports.map((s) => s.getText(old)).join('\n');
+        content = content.slice(0, call.arguments.pos) + optionText + content.slice(call.arguments.end);
+        content = importText + '\n' + content;
+        source = parse(content);
+        const updated = kitCall(source);
+        options = object(updated.arguments[0], source);
+    }
+    const synthetic = mergeAliasesInSvelteConfig(`export default { kit: ${optionText} };`, aliases);
+    const merged = parse(synthetic).statements.find(ts.isExportAssignment);
+    const kit = merged.expression.properties[0];
+    const replacement = kit.initializer.getText(merged.getSourceFile());
+    if (options)
+        return content.slice(0, options.getStart(source)) + replacement + content.slice(options.end);
+    const actual = kitCall(source);
+    return content.slice(0, actual.arguments.pos) + replacement + content.slice(actual.arguments.end);
+}
+function objectOrUndefined(e, source) {
+    try {
+        return object(e, source);
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function formatConfig(content, file) {
+    return format(content, { ...(await resolveConfig(file)), filepath: file, parser: 'typescript' });
+}
+export async function configureKitProject() {
+    const root = process.cwd();
+    const existing = async (names) => {
+        for (const n of names) {
+            try {
+                await fs.access(path.join(root, n));
+                return path.join(root, n);
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    throw error;
+            }
+        }
+    };
+    const vite = await existing(VITE_CONFIGS), legacy = await existing(SVELTE_CONFIGS);
+    if (!vite && !legacy) {
+        console.warn('No Vite config found; initialize a SvelteKit project first.');
+        return;
+    }
+    const file = vite ?? path.join(root, 'vite.config.ts');
+    const content = vite
+        ? await fs.readFile(vite, 'utf8')
+        : "import { defineConfig } from 'vite';\nimport { sveltekit } from '@sveltejs/kit/vite';\nexport default defineConfig({plugins: [sveltekit()]});\n";
+    const old = legacy ? await fs.readFile(legacy, 'utf8') : undefined;
+    const next = await formatConfig(mergeKitViteConfig(content, ARCHITECTURE_ALIASES, old), file);
+    if (legacy) {
+        const backup = await fs.mkdtemp(path.join(await fs
+            .mkdir(path.join(root, '.azure-net/ConfigBackups'), { recursive: true })
+            .then(() => path.join(root, '.azure-net/ConfigBackups')), 'kit3-'));
+        await fs.writeFile(path.join(backup, path.basename(legacy)), old);
+        if (vite)
+            await fs.writeFile(path.join(backup, path.basename(vite)), content);
+    }
+    await fs.writeFile(file, next);
+    if (legacy)
+        await fs.unlink(legacy);
+}
+export function readStaticAliases(content) {
+    const aliases = {};
+    const source = parse(content);
+    const visit = (n) => {
+        if (ts.isPropertyAssignment(n) && name(n.name) === 'alias') {
+            const value = objectOrUndefined(n.initializer, source);
+            if (value)
+                for (const p of value.properties)
+                    if (ts.isPropertyAssignment(p) && name(p.name) && ts.isStringLiteral(p.initializer))
+                        aliases[name(p.name)] = p.initializer.text;
+        }
+        ts.forEachChild(n, visit);
+    };
+    visit(source);
+    return aliases;
+}
+/** Hydratable needs Svelte async mode. Preserve all unrelated literal options. */
+export function enableHydratable(content) {
+    const source = parse(content);
+    const call = kitCall(source);
+    const update = (value, keys) => {
+        const key = keys[0];
+        const props = [...value.properties];
+        const existing = props.find((p) => name(p.name) === key);
+        if (existing && !ts.isPropertyAssignment(existing))
+            throw new Error(`Cannot safely configure ${keys.join('.')}. Use literal compilerOptions.`);
+        if (props.some(ts.isSpreadAssignment))
+            throw new Error('Cannot safely enable async mode in spread options. Set compilerOptions.experimental.async: true manually.');
+        const next = keys.length === 1
+            ? ts.factory.createTrue()
+            : update(existing ? object(existing.initializer, source) : ts.factory.createObjectLiteralExpression(), keys.slice(1));
+        const index = props.findIndex((p) => name(p.name) === key);
+        const property = ts.factory.createPropertyAssignment(key, next);
+        if (index === -1)
+            props.push(property);
+        else
+            props[index] = property;
+        return ts.factory.createObjectLiteralExpression(props, true);
+    };
+    const options = call.arguments[0] ? object(call.arguments[0], source) : ts.factory.createObjectLiteralExpression();
+    const updated = update(options, ['compilerOptions', 'experimental', 'async']);
+    return (content.slice(0, call.getStart(source)) +
+        `${call.expression.getText(source)}(${ts.createPrinter().printNode(ts.EmitHint.Expression, updated, source)})` +
+        content.slice(call.end));
+}

package/.prettierrc

@@ -1,7 +0,0 @@
-{
-	"useTabs": true,
-	"singleQuote": true,
-	"trailingComma": "none",
-	"printWidth": 140,
-	"semi": true
-}

package/bin/azure-net.ts

@@ -1,308 +0,0 @@
-#!/usr/bin/env node
-
-import { Command } from 'commander';
-import { addLint } from '../src/plugins/index.js';
-
-const program = new Command();
-
-program.name('azure-net').description('Azure-Net CLI generator').version('4.1.0');
-
-const addCommand = program.command('add').description('Add project integrations and plugins');
-const createCommand = program.command('create').description('Create project boilerplate artifacts');
-const initCommand = program.command('init').description('Initialize project scaffolding');
-const installCommand = program.command('install').description('Install project presets and flows');
-const generateCommand = program.command('generate').description('Generate UI artifacts');
-const checkCommand = program.command('check').description('Run project checks');
-
-addCommand
-	.command('commit-tools')
-	.description('Setup linting and commit tools')
-	.option('-m, --manager <manager>', 'Package manager: bun | pnpm | npm | yarn')
-	.action(addLint);
-
-createCommand
-	.command('schema-factory')
-	.description('Create base schema in shared essentials foundation constructs')
-	.action(async () => {
-		const handler = (await import('../src/scaffolds/createCoreSchema.js')).default;
-		await handler();
-	});
-
-createCommand
-	.command('translation-manager')
-	.description('Create translation manager in shared essentials localization')
-	.action(async () => {
-		const handler = (await import('../src/scaffolds/createTranslationManager.js')).default;
-		await handler();
-	});
-
-createCommand
-	.command('presenter-factory')
-	.description('Create presenter factory in shared essentials foundation constructs')
-	.action(async () => {
-		const handler = (await import('../src/scaffolds/createPresenterFactory.js')).default;
-		await handler();
-	});
-
-createCommand
-	.command('schema-rule')
-	.description('Create schema rule in shared essentials foundation constructs')
-	.action(async () => {
-		const handler = (await import('../src/scaffolds/createSchemaRule.js')).default;
-		await handler();
-	});
-
-createCommand
-	.command('response')
-	.description('Create response in shared essentials foundation constructs')
-	.action(async () => {
-		const handler = (await import('../src/scaffolds/createResponse.js')).default;
-		await handler();
-	});
-
-createCommand
-	.command('datasource')
-	.description('Create datasource in core or context infrastructure')
-	.action(async () => {
-		const handler = (await import('../src/scaffolds/createDatasource.js')).default;
-		await handler();
-	});
-
-createCommand
-	.command('datasource-provider')
-	.description('Create datasource provider in core or context infrastructure')
-	.action(async () => {
-		const handler = (await import('../src/scaffolds/createDatasourceProvider.js')).default;
-		await handler();
-	});
-
-initCommand
-	.command('edges')
-	.description('Initialize edges plugin in vite config')
-	.action(async () => {
-		const handler = (await import('../src/init/initEdges.js')).default;
-		await handler();
-	});
-
-initCommand
-	.command('folders-structure')
-	.description('Generate base folders structure')
-	.action(async () => {
-		const handler = (await import('../src/init/initStructure.js')).default;
-		await handler();
-	});
-
-initCommand.action(async () => {
-	const initStructure = (await import('../src/init/initStructure.js')).default;
-	await initStructure();
-});
-
-installCommand
-	.command('fresh')
-	.description('Run full fresh install flow (structure + optional generators)')
-	.action(async () => {
-		const handler = (await import('../src/install/installFresh.js')).default;
-		await handler();
-	});
-
-generateCommand
-	.command('component')
-	.description('Generate UI component')
-	.action(async () => {
-		const handler = (await import('../src/generate/ui/generateComponent.js')).default;
-		await handler();
-	});
-
-generateCommand
-	.command('widget')
-	.description('Generate UI widget')
-	.action(async () => {
-		const handler = (await import('../src/generate/ui/generateWidget.js')).default;
-		await handler();
-	});
-
-generateCommand
-	.command('design-component')
-	.description('Generate UI design component')
-	.action(async () => {
-		const handler = (await import('../src/generate/ui/generateDesignComponent.js')).default;
-		await handler();
-	});
-
-generateCommand
-	.command('repository')
-	.description('Generate infrastructure repository')
-	.action(async () => {
-		const handler = (await import('../src/generate/layers/generateRepository.js')).default;
-		await handler();
-	});
-
-generateCommand
-	.command('repo')
-	.description('Generate infrastructure repository (module flow)')
-	.action(async () => {
-		const handler = (await import('../src/generate/module/generateRepository.js')).default;
-		await handler();
-	});
-
-generateCommand
-	.command('repository-method')
-	.description('Generate method for an existing repository')
-	.action(async () => {
-		const handler = (await import('../src/generate/layers/generateRepositoryMethod.js')).default;
-		await handler();
-	});
-
-generateCommand
-	.command('use-cases')
-	.description('Generate use-cases for an existing repository')
-	.action(async () => {
-		const handler = (await import('../src/generate/module/generateUseCases.js')).default;
-		await handler();
-	});
-
-generateCommand
-	.command('domain')
-	.description('Generate domain module (model/ports)')
-	.action(async () => {
-		const handler = (await import('../src/generate/module/generateDomain.js')).default;
-		await handler();
-	});
-
-generateCommand
-	.command('presenter')
-	.description('Generate presentation layer presenter from UseCases')
-	.action(async () => {
-		const handler = (await import('../src/generate/module/generatePresenter.js')).default;
-		await handler();
-	});
-
-generateCommand
-	.command('types-json')
-	.description('Fill model interface keys from JSON')
-	.action(async () => {
-		const handler = (await import('../src/generate/module/generateTypesJson.js')).default;
-		await handler();
-	});
-
-generateCommand
-	.command('schema-from-type')
-	.description('Fill schema rules keys from schema generic type')
-	.action(async () => {
-		const handler = (await import('../src/generate/module/generateSchemaFromType.js')).default;
-		await handler();
-	});
-
-generateCommand
-	.command('module')
-	.description('Generate domain + repository + presenter flow')
-	.action(async () => {
-		const handler = (await import('../src/generate/module/generateModule.js')).default;
-		await handler();
-	});
-
-generateCommand
-	.command('module-preset')
-	.description('Generate preset CRUD-like module flow')
-	.action(async () => {
-		const handler = (await import('../src/generate/module/generateModulePreset.js')).default;
-		await handler();
-	});
-
-generateCommand
-	.command('routes')
-	.description('Generate typed SvelteKit routes list')
-	.action(async () => {
-		const handler = (await import('../src/generate/routes/generateRoutes.js')).default;
-		await handler();
-	});
-
-checkCommand
-	.command('presenter-names')
-	.description('Check duplicate presenter names in src')
-	.action(async () => {
-		const handler = (await import('../src/checks/checkPresenterNames.js')).default;
-		await handler();
-	});
-
-checkCommand
-	.command('provider-names')
-	.description('Check duplicate provider names in src')
-	.action(async () => {
-		const handler = (await import('../src/checks/checkProviderNames.js')).default;
-		await handler();
-	});
-
-checkCommand
-	.command('provider-graph')
-	.description('Check provider dependency graph for cycles')
-	.action(async () => {
-		const handler = (await import('../src/checks/checkProviderGraph.js')).default;
-		await handler();
-	});
-
-checkCommand
-	.command('domain')
-	.description('Check domain naming and structure rules in all contexts')
-	.action(async () => {
-		const handler = (await import('../src/checks/checkDomain.js')).default;
-		await handler();
-	});
-
-checkCommand
-	.command('imports')
-	.description('Check import extensions and import group order in src')
-	.action(async () => {
-		const handler = (await import('../src/checks/checkImports.js')).default;
-		await handler();
-	});
-
-checkCommand
-	.command('hooks')
-	.description('Check that manual SvelteKit hooks are not present')
-	.action(async () => {
-		const handler = (await import('../src/checks/checkHooks.js')).default;
-		await handler();
-	});
-
-checkCommand
-	.command('layer-imports')
-	.description('Check forbidden imports between layers inside each context')
-	.action(async () => {
-		const handler = (await import('../src/checks/checkLayerImports.js')).default;
-		await handler();
-	});
-
-checkCommand
-	.command('layer-boundaries')
-	.description('Check layer boundaries between contexts by aliases')
-	.action(async () => {
-		const handler = (await import('../src/checks/checkLayerBoundaries.js')).default;
-		await handler();
-	});
-
-checkCommand
-	.command('folders-structure')
-	.description('Check allowed folders structure in context layers/ui/components')
-	.action(async () => {
-		const handler = (await import('../src/checks/checkFoldersStructure.js')).default;
-		await handler();
-	});
-
-checkCommand
-	.command('internal')
-	.description('Run all internal azure-net checks')
-	.action(async () => {
-		const handler = (await import('../src/checks/checkInternal.js')).default;
-		await handler();
-	});
-
-checkCommand
-	.command('project')
-	.description('Run full project checks: format, internal, lint, typecheck')
-	.action(async () => {
-		const handler = (await import('../src/checks/checkProject.js')).default;
-		await handler();
-	});
-
-program.parse();

package/eslint.config.js

@@ -1,34 +0,0 @@
-import js from '@eslint/js';
-import tseslint from 'typescript-eslint';
-
-export default tseslint.config(
-	{
-		ignores: ['dist/**', 'node_modules/**']
-	},
-	js.configs.recommended,
-	...tseslint.configs.recommended,
-	{
-		files: ['bin/**/*.ts', 'src/plugins/**/*.ts'],
-		languageOptions: {
-			globals: {
-				console: 'readonly',
-				process: 'readonly'
-			}
-		}
-	},
-	{
-		files: [
-			'src/generate/module/repositoryModuleShared.ts',
-			'src/generate/layers/repositoryShared.ts',
-			'src/generate/layers/generateUseCases.ts',
-			'src/generate/layers/generateRepositoryMethod.ts',
-			'src/generate/layers/generateRepository.ts',
-			'src/utils/contextUtils.ts',
-			'src/utils/loadConfig.ts',
-			'src/utils/fileUtils.ts'
-		],
-		rules: {
-			'@typescript-eslint/ban-ts-comment': 'off'
-		}
-	}
-);