@azure-net/cli 1.4.2 → 2.0.0

package/src/commands/generate/generateRepository.js

@@ -0,0 +1,97 @@
+import prompts from 'prompts';
+import fs from 'fs/promises';
+import path from 'path';
+import { selectContext, getContextPath, toPascalCase, getAvailableFiles } from '../../utils/contextUtils.js';
+import { writeIfNotExists, updateIndexTs } from '../../utils/fileUtils.js';
+import { ensureProvider, addToProvider } from '../../utils/providerUtils.js';
+
+const repositoryTemplate = `import { {{datasource}} } from '{{datasourceImport}}';
+
+export class {{name}}Repository {
+\tconstructor(private {{datasourceVar}}: {{datasource}}) {}
+\t
+\tpublic async example() {
+\t\treturn this.{{datasourceVar}}.createRequest(({ http }) => 
+\t\t\thttp.get('/endpoint')
+\t\t).then(res => res.getData());
+\t}
+}`;
+
+export default async function generateRepository() {
+    const context = await selectContext('Select context for repository:');
+
+    if (context === 'core') {
+        console.error('❌ Cannot create repository in core. Choose a specific context.');
+        return;
+    }
+
+    const { name } = await prompts({
+        type: 'text',
+        name: 'name',
+        message: 'Repository name (without "Repository" suffix):'
+    });
+
+    // Get available datasources
+    const contextPath = getContextPath(context);
+    const coreDatasources = await getAvailableFiles(
+        path.join(process.cwd(), 'src/app/core/Datasources')
+    );
+    const contextDatasources = await getAvailableFiles(
+        path.join(contextPath, 'Infrastructure', 'Datasources')
+    );
+
+    const allDatasources = [
+        ...coreDatasources.map(d => ({ title: `${d}Datasource (core)`, value: { name: `${d}Datasource`, from: 'core' } })),
+        ...contextDatasources.map(d => ({ title: `${d}Datasource (${context})`, value: { name: `${d}Datasource`, from: context } }))
+    ];
+
+    if (allDatasources.length === 0) {
+        console.error('❌ No datasources available. Create a datasource first.');
+        return;
+    }
+
+    const { datasource } = await prompts({
+        type: 'select',
+        name: 'datasource',
+        message: 'Select datasource:',
+        choices: allDatasources
+    });
+
+    const pascalName = toPascalCase(name);
+    const repoPath = path.join(contextPath, 'Infrastructure', 'Repositories');
+    const filePath = path.join(repoPath, `${pascalName}Repository.ts`);
+
+    // Generate repository
+    const datasourceImport = datasource.from === 'core'
+        ? '$core/Datasources/index.js'
+        : '../Datasources/index.js';
+
+    const content = repositoryTemplate
+        .replace(/{{name}}/g, pascalName)
+        .replace(/{{datasource}}/g, datasource.name)
+        .replace(/{{datasourceImport}}/g, datasourceImport)
+        .replace(/{{datasourceVar}}/g, toPascalCase(datasource.name).charAt(0).toLowerCase() + toPascalCase(datasource.name).slice(1));
+
+    await writeIfNotExists(filePath, content);
+    await updateIndexTs(repoPath);
+
+    // Ensure DatasourceProvider exists
+    const datasourceProvider = await ensureProvider(context, 'Infrastructure', { datasource: datasource.name });
+
+    // Ensure InfrastructureProvider exists and add repository
+    const infraProvider = await ensureProvider(context, 'Infrastructure', { datasource: datasource.name });
+    await addToProvider(
+        infraProvider.path,
+        `${pascalName}Repository`,
+        '../Repositories/index.js'
+    );
+
+    // Add datasource dependency to repository in provider
+    let providerContent = await fs.readFile(infraProvider.path, 'utf-8');
+    const repoFactory = `${pascalName}Repository: () => new ${pascalName}Repository()`;
+    const repoWithDatasource = `${pascalName}Repository: () => new ${pascalName}Repository(DatasourceProvider.${datasource.name})`;
+    providerContent = providerContent.replace(repoFactory, repoWithDatasource);
+    await fs.writeFile(infraProvider.path, providerContent, 'utf-8');
+
+    console.log(`✅ Repository created at ${filePath}`);
+}

package/src/commands/generate/generateResponse.js

@@ -0,0 +1,42 @@
+import prompts from 'prompts';
+import { selectContext, getContextPath, toPascalCase } from '../../utils/contextUtils.js';
+import { writeIfNotExists, updateIndexTs } from '../../utils/fileUtils.js';
+import path from 'path';
+
+const responseTemplate = `import { ResponseBuilder } from '@azure-net/kit';
+
+export interface I{{name}}Response<T = unknown> {
+\tdata: T;
+\tsuccess: boolean;
+\tmessage: string;
+}
+
+export class {{name}}Response<TData = unknown, TMeta = unknown> extends ResponseBuilder<TData, TMeta, I{{name}}Response<TData>> {
+\toverride unwrapData(data: I{{name}}Response<TData>): TData {
+\t\treturn data.data;
+\t}
+}`;
+
+export default async function generateResponse() {
+    const context = await selectContext();
+
+    const { name } = await prompts({
+        type: 'text',
+        name: 'name',
+        message: 'Response name (PascalCase):'
+    });
+
+    const pascalName = toPascalCase(name);
+    const contextPath = getContextPath(context);
+    const responsePath = context === 'core'
+        ? path.join(contextPath, 'Responses')
+        : path.join(contextPath, 'Infrastructure', 'Responses');
+
+    const content = responseTemplate.replace(/{{name}}/g, pascalName);
+    const filePath = path.join(responsePath, `${pascalName}Response.ts`);
+
+    await writeIfNotExists(filePath, content);
+    await updateIndexTs(responsePath);
+
+    console.log(`✅ Response created at ${filePath}`);
+}

package/src/commands/generate/generateSchema.js

@@ -0,0 +1,70 @@
+import prompts from 'prompts';
+import path from 'path';
+import { selectContext, getContextPath, toPascalCase, getAvailableFiles } from '../../utils/contextUtils.js';
+import { writeIfNotExists, updateIndexTs } from '../../utils/fileUtils.js';
+
+const schemaWithCoreTemplate = `import { {{coreSchema}} } from '$core/Schemas/index.js';
+import type { I{{name}}Request } from '../../Domain/Ports/{{name}}/index.js';
+
+export const {{name}}Schema = {{coreSchema}}<I{{name}}Request>()
+\t.rules((rules) => ({
+\t\t// Add validation rules here
+\t}))
+\t.create();`;
+
+const schemaWithPackageTemplate = `import { schema } from '@azure-net/kit';
+import type { I{{name}}Request } from '../../Domain/Ports/{{name}}/index.js';
+
+export const {{name}}Schema = schema<I{{name}}Request>()
+\t.rules((rules) => ({
+\t\t// Add validation rules here
+\t}))
+\t.create();`;
+
+export default async function generateSchema() {
+    const context = await selectContext('Select context for schema:');
+
+    if (context === 'core') {
+        console.error('❌ Cannot create schema in core. Choose a specific context.');
+        return;
+    }
+
+    const { name } = await prompts({
+        type: 'text',
+        name: 'name',
+        message: 'Schema name (without "Schema" suffix):'
+    });
+
+    // Check for core schemas
+    const coreSchemas = await getAvailableFiles(
+        path.join(process.cwd(), 'src/app/core/Schemas')
+    );
+
+    const choices = [
+        { title: 'Use schema from package', value: 'package' },
+        ...coreSchemas.map(s => ({ title: `Use ${s} from core`, value: s }))
+    ];
+
+    const { schemaType } = await prompts({
+        type: 'select',
+        name: 'schemaType',
+        message: 'Select schema factory:',
+        choices
+    });
+
+    const pascalName = toPascalCase(name);
+    const contextPath = getContextPath(context);
+    const schemaPath = path.join(contextPath, 'Delivery', 'Schemas');
+    const filePath = path.join(schemaPath, `${pascalName}Schema.ts`);
+
+    const content = schemaType === 'package'
+        ? schemaWithPackageTemplate.replace(/{{name}}/g, pascalName)
+        : schemaWithCoreTemplate
+            .replace(/{{name}}/g, pascalName)
+            .replace(/{{coreSchema}}/g, schemaType);
+
+    await writeIfNotExists(filePath, content);
+    await updateIndexTs(schemaPath);
+
+    console.log(`✅ Schema created at ${filePath}`);
+}

package/src/commands/generate/generateService.js

@@ -0,0 +1,93 @@
+import prompts from 'prompts';
+import fs from 'fs/promises';
+import path from 'path';
+import { selectContext, getContextPath, toPascalCase, getAvailableFiles } from '../../utils/contextUtils.js';
+import { writeIfNotExists, updateIndexTs } from '../../utils/fileUtils.js';
+import { ensureProvider, addToProvider } from '../../utils/providerUtils.js';
+
+const serviceTemplate = `import { ClassMirror } from '@azure-net/kit';
+import { {{repository}} } from '../../Infrastructure/Repositories/index.js';
+
+export class {{name}}Service extends ClassMirror<{{repository}}> {
+\tconstructor(private {{repositoryVar}}: {{repository}}) {
+\t\tsuper({{repositoryVar}});
+\t}
+\t
+\tdeclare example: {{repository}}['example'];
+}`;
+
+const serviceWithoutRepoTemplate = `export class {{name}}Service {
+\tconstructor() {}
+\t
+\tpublic async example() {
+\t\t// Implement service logic
+\t\treturn {};
+\t}
+}`;
+
+export default async function generateService() {
+    const context = await selectContext('Select context for service:');
+
+    if (context === 'core') {
+        console.error('❌ Cannot create service in core. Choose a specific context.');
+        return;
+    }
+
+    const { name } = await prompts({
+        type: 'text',
+        name: 'name',
+        message: 'Service name (without "Service" suffix):'
+    });
+
+    // Get available repositories
+    const contextPath = getContextPath(context);
+    const repositories = await getAvailableFiles(
+        path.join(contextPath, 'Infrastructure', 'Repositories')
+    );
+
+    const choices = [
+        { title: 'Without repository', value: null },
+        ...repositories.map(r => ({ title: `${r}Repository`, value: `${r}Repository` }))
+    ];
+
+    const { repository } = await prompts({
+        type: 'select',
+        name: 'repository',
+        message: 'Select repository:',
+        choices
+    });
+
+    const pascalName = toPascalCase(name);
+    const servicePath = path.join(contextPath, 'Application', 'Services');
+    const filePath = path.join(servicePath, `${pascalName}Service.ts`);
+
+    // Generate service
+    const content = repository
+        ? serviceTemplate
+            .replace(/{{name}}/g, pascalName)
+            .replace(/{{repository}}/g, repository)
+            .replace(/{{repositoryVar}}/g, repository.charAt(0).toLowerCase() + repository.slice(1))
+        : serviceWithoutRepoTemplate.replace(/{{name}}/g, pascalName);
+
+    await writeIfNotExists(filePath, content);
+    await updateIndexTs(servicePath);
+
+    // Ensure ApplicationProvider exists and add service
+    const appProvider = await ensureProvider(context, 'Application', { infrastructure: true });
+    await addToProvider(
+        appProvider.path,
+        `${pascalName}Service`,
+        '../Services/index.js'
+    );
+
+    // Add repository dependency if selected
+    if (repository) {
+        let providerContent = await fs.readFile(appProvider.path, 'utf-8');
+        const serviceFactory = `${pascalName}Service: () => new ${pascalName}Service()`;
+        const serviceWithRepo = `${pascalName}Service: () => new ${pascalName}Service(InfrastructureProvider.${repository})`;
+        providerContent = providerContent.replace(serviceFactory, serviceWithRepo);
+        await fs.writeFile(appProvider.path, providerContent, 'utf-8');
+    }
+
+    console.log(`✅ Service created at ${filePath}`);
+}

package/src/commands/generate/index.js

@@ -0,0 +1,8 @@
+export { default as generateDatasource } from './generateDatasource.js';
+export { default as generateResponse } from './generateResponse.js';
+export { default as generateRepository } from './generateRepository.js';
+export { default as generateService } from './generateService.js';
+export { default as generateSchema } from './generateSchema.js';
+export { default as generatePresenter } from './generatePresenter.js';
+export { default as generateModule } from './generateModule.js';
+export { default as generateCrud } from './generateCrud.js';

package/src/commands/init/index.js

@@ -0,0 +1,6 @@
+export { default as initStructure } from './initStructure.js';
+export { default as initAliases } from './initAliases.js';
+export { default as initMiddleware } from './initMiddleware.js';
+export { default as initEdges } from './initEdges.js';
+export { default as initTranslations } from './initTranslations.js';
+export { default as initSchema } from './initSchema.js';

package/src/commands/init/initAliases.js

@@ -0,0 +1,50 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { loadUserConfig } from '../../utils/loadConfig.js';
+import { execSync } from 'child_process';
+
+const svelteConfigPath = path.resolve('svelte.config.js');
+
+function generateAliases(config) {
+    const contexts = config.contexts || ['app'];
+
+    return Object.fromEntries([
+        ...contexts.map(c => [`$${c}`, `./src/app/contexts/${c}`]),
+        ['$core', './src/app/core'],
+        ['$lib', './src/lib']
+    ]);
+}
+
+function serializeObjectLiteral(obj) {
+    return Object.entries(obj)
+        .map(([key, value]) => `\t\t\t'${key}': '${value}'`)
+        .join(',\n');
+}
+
+export default async function initAliases() {
+    const config = await loadUserConfig();
+    const newAliases = generateAliases(config);
+
+    let content = await fs.readFile(svelteConfigPath, 'utf-8');
+
+    const aliasRegex = /alias:\s*{([\s\S]*?)}/m;
+    const aliasMatch = content.match(aliasRegex);
+
+    const newAliasBlock = `alias: {\n${serializeObjectLiteral(newAliases)}\n\t\t}`;
+
+    if (aliasMatch) {
+        content = content.replace(aliasRegex, newAliasBlock);
+    } else {
+        const kitRegex = /kit:\s*{/;
+        content = content.replace(kitRegex, `kit: {\n\t\t${newAliasBlock},`);
+    }
+
+    await fs.writeFile(svelteConfigPath, content, 'utf-8');
+    console.log('✅ Aliases updated in svelte.config.js');
+
+    try {
+        execSync('npm run format', { stdio: 'inherit' });
+    } catch {
+        console.warn('⚠️ Failed to run format');
+    }
+}

package/src/commands/init/initEdges.js

@@ -0,0 +1,42 @@
+import { injectIntoFile, writeIfNotExists } from '../../utils/fileUtils.js';
+import path from 'path';
+
+const hooksServerPath = path.join(process.cwd(), 'src/hooks.server.ts');
+
+const hooksTemplate = `import { dev } from '$app/environment';
+import { edgesHandle } from '@azure-net/kit/edges/server';
+import { type Handle } from '@sveltejs/kit';
+
+export const handle: Handle = async ({ event, resolve }) => {
+\treturn edgesHandle(
+\t\tevent,
+\t\tasync ({ edgesEvent, serialize }) => {
+\t\t\treturn resolve(edgesEvent, {
+\t\t\t\ttransformPageChunk: ({ html }) => serialize(html)
+\t\t\t});
+\t\t},
+\t\tdev
+\t);
+};`;
+
+export default async function initEdges() {
+    const created = await writeIfNotExists(hooksServerPath, hooksTemplate);
+
+    if (!created) {
+        const importStatement = `import { edgesHandle } from '@azure-net/kit/edges/server';`;
+        await injectIntoFile(hooksServerPath, 'import {', importStatement, 'before');
+
+        const handleCode = `\treturn edgesHandle(
+\t\tevent,
+\t\tasync ({ edgesEvent, serialize }) => {`;
+
+        await injectIntoFile(
+            hooksServerPath,
+            'export const handle: Handle = async ({ event, resolve }) => {',
+            handleCode,
+            'after'
+        );
+    }
+
+    console.log('✅ Edges-svelte initialized');
+}

package/src/commands/init/initMiddleware.js

@@ -0,0 +1,58 @@
+import { writeIfNotExists, injectIntoFile } from '../../utils/fileUtils.js';
+import path from 'path';
+
+const middlewarePath = path.join(process.cwd(), 'src/app/core/Middleware/MiddlewareManager.ts');
+const hooksServerPath = path.join(process.cwd(), 'src/hooks.server.ts');
+const layoutPath = path.join(process.cwd(), 'src/routes/+layout.svelte');
+
+const middlewareTemplate = `import { createMiddlewareManager, type IMiddleware } from '@azure-net/kit';
+
+const AuthMiddleware: IMiddleware = async ({ next, page, event, isServer, cookies }) => {
+\tconst user = isServer ? event?.locals?.user : page?.data?.user;
+\tif (isServer && !user && cookies.get('token') && event) {
+\t\t// Add auth logic here
+\t}
+\tnext();
+};
+
+const GuardMiddleware: IMiddleware = async ({ next, page, event, isServer, to }) => {
+\tconst user = isServer ? event?.locals?.user : page?.data?.user;
+\tif (!user && !to.pathname.startsWith('/login')) {
+\t\tnext('/login');
+\t}
+\tif (user && to.pathname.startsWith('/login')) {
+\t\tnext('/');
+\t}
+\tnext();
+};
+
+export const { clientMiddleware, serverMiddleware } = createMiddlewareManager([AuthMiddleware, GuardMiddleware]);`;
+
+export default async function initMiddleware() {
+    await writeIfNotExists(middlewarePath, middlewareTemplate);
+
+    // Add to hooks.server.ts
+    await injectIntoFile(
+        hooksServerPath,
+        `import { serverMiddleware } from '$core/Middleware/index.js';`,
+        'import',
+        'before'
+    );
+
+    await injectIntoFile(
+        hooksServerPath,
+        'async ({ edgesEvent, serialize }) => {',
+        '\t\t\tawait serverMiddleware();',
+        'after'
+    );
+
+    // Add to +layout.svelte
+    await injectIntoFile(
+        layoutPath,
+        '<script',
+        `\timport { clientMiddleware } from '$core/Middleware/index.js';\n\tclientMiddleware();`,
+        'after'
+    );
+
+    console.log('✅ Middleware initialized');
+}

package/src/commands/init/initSchema.js

@@ -0,0 +1,19 @@
+import { writeIfNotExists } from '../../utils/fileUtils.js';
+import path from 'path';
+
+const schemaPath = path.join(process.cwd(), 'src/app/core/Schemas/Schema.ts');
+
+const schemaTemplate = `import { createSchemaFactory } from '@azure-net/kit/schema';
+import { createRules, validationMessagesI18n } from '@azure-net/kit/schema';
+
+export const Schema = createSchemaFactory(createRules(validationMessagesI18n));`;
+
+export default async function initSchema() {
+    await writeIfNotExists(schemaPath, schemaTemplate);
+    await writeIfNotExists(
+        path.join(process.cwd(), 'src/app/core/Schemas/index.ts'),
+        `export * from './Schema.js';`
+    );
+
+    console.log('✅ Schema factory initialized');
+}

package/src/commands/init/initStructure.js

@@ -0,0 +1,68 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { loadUserConfig } from '../../utils/loadConfig.js';
+
+const BASE_STRUCTURE = ['Domain', 'Infrastructure', 'Application', 'Delivery'];
+const APP_ROOT = path.join(process.cwd(), 'src', 'app');
+const CONTEXTS_PATH = path.join(APP_ROOT, 'contexts');
+const CORE_PATH = path.join(APP_ROOT, 'core');
+
+async function createDirIfNotExists(dirPath) {
+    try {
+        await fs.mkdir(dirPath, { recursive: true });
+        console.log(`📁 Created: ${dirPath}`);
+    } catch (e) {
+        console.error(`❌ Failed to create ${dirPath}:`, e.message);
+    }
+}
+
+async function createBaseStructure(root) {
+    for (const section of BASE_STRUCTURE) {
+        const sectionPath = path.join(root, section);
+        await createDirIfNotExists(sectionPath);
+
+        if (section === 'Infrastructure') {
+            await createDirIfNotExists(path.join(sectionPath, 'Repositories'));
+            await createDirIfNotExists(path.join(sectionPath, 'Datasources'));
+            await createDirIfNotExists(path.join(sectionPath, 'Providers'));
+        }
+        if (section === 'Application') {
+            await createDirIfNotExists(path.join(sectionPath, 'Services'));
+            await createDirIfNotExists(path.join(sectionPath, 'Providers'));
+        }
+        if (section === 'Domain') {
+            await createDirIfNotExists(path.join(sectionPath, 'Entities'));
+            await createDirIfNotExists(path.join(sectionPath, 'Ports'));
+        }
+        if (section === 'Delivery') {
+            await createDirIfNotExists(path.join(sectionPath, 'Presenters'));
+            await createDirIfNotExists(path.join(sectionPath, 'Schemas'));
+            await createDirIfNotExists(path.join(sectionPath, 'Actions'));
+            await createDirIfNotExists(path.join(sectionPath, 'Stores'));
+        }
+    }
+}
+
+export default async function initStructure() {
+    const config = await loadUserConfig();
+    const contexts = config.contexts || ['app'];
+
+    console.log('📦 Generating architecture...');
+
+    // Create contexts
+    for (const context of contexts) {
+        const contextPath = path.join(CONTEXTS_PATH, context);
+        await createBaseStructure(contextPath);
+    }
+
+    // Create core structure
+    await createDirIfNotExists(CORE_PATH);
+    await createDirIfNotExists(path.join(CORE_PATH, 'Datasources'));
+    await createDirIfNotExists(path.join(CORE_PATH, 'Responses'));
+    await createDirIfNotExists(path.join(CORE_PATH, 'Schemas'));
+    await createDirIfNotExists(path.join(CORE_PATH, 'Middleware'));
+    await createDirIfNotExists(path.join(CORE_PATH, 'Presenters'));
+    await createDirIfNotExists(path.join(CORE_PATH, 'Translations'));
+
+    console.log('✅ Structure initialization complete!');
+}

package/src/commands/init/initTranslations.js

@@ -0,0 +1,97 @@
+import { writeIfNotExists, updateIndexTs, injectIntoFile } from '../../utils/fileUtils.js';
+import path from 'path';
+
+const translationsPath = path.join(process.cwd(), 'src/app/core/Translations');
+const layoutServerPath = path.join(process.cwd(), 'src/routes/+layout.server.ts');
+const layoutTsPath = path.join(process.cwd(), 'src/routes/+layout.ts');
+
+const translationProviderTemplate = `import { messages } from './Locales/index.js';
+import { createTranslations } from '@azure-net/kit/i18n';
+
+export const Translation = createTranslations({ 
+\tmessages, 
+\tinitLang: 'en', 
+\tinitLangFromAcceptLanguage: true, 
+\tcookieName: 'lang' 
+});`;
+
+const enLocaleTemplate = `export default {
+\tapp: {
+\t\ttitle: 'Application'
+\t}
+};`;
+
+const ruLocaleTemplate = `export default {
+\tapp: {
+\t\ttitle: 'Приложение'
+\t}
+};`;
+
+const localesIndexTemplate = `export const messages = {
+\ten: () => import('./en.js').then((res) => res.default),
+\tru: () => import('./ru.js').then((res) => res.default)
+};`;
+
+export default async function initTranslations() {
+    // Create translation files
+    await writeIfNotExists(
+        path.join(translationsPath, 'index.ts'),
+        translationProviderTemplate
+    );
+
+    await writeIfNotExists(
+        path.join(translationsPath, 'Locales', 'en.ts'),
+        enLocaleTemplate
+    );
+
+    await writeIfNotExists(
+        path.join(translationsPath, 'Locales', 'ru.ts'),
+        ruLocaleTemplate
+    );
+
+    await writeIfNotExists(
+        path.join(translationsPath, 'Locales', 'index.ts'),
+        localesIndexTemplate
+    );
+
+    await updateIndexTs(translationsPath);
+
+    // Add to hooks.server.ts
+    await injectIntoFile(
+        path.join(process.cwd(), 'src/hooks.server.ts'),
+        'import',
+        `import { Translation } from '$core/Translations/index.js';`,
+        'before'
+    );
+
+    await injectIntoFile(
+        path.join(process.cwd(), 'src/hooks.server.ts'),
+        'await serverMiddleware();',
+        `\t\t\tconst { preloadTranslation, applyHtmlLocaleAttr } = Translation();\n\t\t\tawait preloadTranslation(edgesEvent);`,
+        'after'
+    );
+
+    // Add to layout files
+    await injectIntoFile(
+        layoutServerPath,
+        'export const load',
+        `\treturn { lang: locals.lang, user: locals.user };`,
+        'after'
+    );
+
+    await injectIntoFile(
+        layoutTsPath,
+        'import',
+        `import { Translation } from '$core/Translations/index.js';`,
+        'before'
+    );
+
+    await injectIntoFile(
+        layoutTsPath,
+        'export const load',
+        `\tconst { syncTranslation } = Translation();\n\tif (browser) {\n\t\tawait syncTranslation({ lang: data.lang }, false);\n\t}`,
+        'after'
+    );
+
+    console.log('✅ Translations initialized');
+}