@azure-net/cli 2.3.62 → 4.0.0-0

package/src/scaffolds/createPresenterFactory.ts

@@ -0,0 +1,114 @@
+import fs from 'node:fs/promises';
+import fsSync from 'node:fs';
+import path from 'node:path';
+import prompts from 'prompts';
+import { writeIfNotExists, updateIndexTs } from '../utils/fileUtils.js';
+import { toPascalCase } from '../utils/contextUtils.js';
+
+type ConfigPath = 'ts' | 'js';
+
+const createPresenterFactoryTemplate = (
+	factoryName: string
+): string => `import { createErrorHandler, createAsyncHelpers, createPresenterFactory } from '@azure-net/kit/delivery';
+
+export const AsyncHelpers = createAsyncHelpers({ handler: createErrorHandler() });
+
+export const ${factoryName} = createPresenterFactory({ ...AsyncHelpers });
+`;
+
+const resolveConfigFile = (cwd: string): { filepath: string; type: ConfigPath; exists: boolean; content: string } => {
+	const tsPath = path.join(cwd, 'azure-net.config.ts');
+	const jsPath = path.join(cwd, 'azure-net.config.js');
+
+	if (fsSync.existsSync(tsPath)) {
+		return { filepath: tsPath, type: 'ts', exists: true, content: fsSync.readFileSync(tsPath, 'utf-8') };
+	}
+	if (fsSync.existsSync(jsPath)) {
+		return { filepath: jsPath, type: 'js', exists: true, content: fsSync.readFileSync(jsPath, 'utf-8') };
+	}
+
+	return { filepath: tsPath, type: 'ts', exists: false, content: '' };
+};
+
+const buildDefaultPresenterFactoryConfigEntry = (factoryName: string): string => {
+	return `defaultPresenterFactory: '${factoryName}'`;
+};
+
+const upsertDefaultPresenterFactoryConfig = (content: string, factoryName: string): string => {
+	const hasExportDefaultObject = /export\s+default\s*\{[\s\S]*\}\s*;?/.test(content);
+	const defaultFactoryEntry = buildDefaultPresenterFactoryConfigEntry(factoryName);
+	const coreAliasEntry = `coreAlias: '$core'`;
+
+	if (!hasExportDefaultObject) {
+		return `export default {\n\t${coreAliasEntry},\n\t${defaultFactoryEntry}\n};\n`;
+	}
+
+	let nextContent = content;
+
+	if (/defaultPresenterFactory\s*:/.test(nextContent)) {
+		nextContent = nextContent.replace(/defaultPresenterFactory\s*:\s*(\{[\s\S]*?\n\s*\}|['"`][^'"`]+['"`])/m, defaultFactoryEntry);
+	} else if (/defaultPresenter\s*:/.test(nextContent)) {
+		nextContent = nextContent.replace(/defaultPresenter\s*:\s*(\{[\s\S]*?\n\s*\}|['"`][^'"`]+['"`])/m, defaultFactoryEntry);
+	} else {
+		nextContent = nextContent.replace(/export\s+default\s*\{([\s\S]*)\}\s*;?/, (_full, body: string) => {
+			const trimmedRight = body.replace(/\s*$/, '');
+			if (!trimmedRight.length) {
+				return `export default {\n\t${defaultFactoryEntry}\n};`;
+			}
+
+			const withComma = trimmedRight.endsWith(',') ? trimmedRight : `${trimmedRight},`;
+			return `export default {${withComma}\n\t${defaultFactoryEntry}\n};`;
+		});
+	}
+
+	if (/coreAlias\s*:/.test(nextContent)) {
+		return nextContent.replace(/coreAlias\s*:\s*['"`][^'"`]+['"`]/, coreAliasEntry);
+	}
+
+	return nextContent.replace(/export\s+default\s*\{([\s\S]*)\}\s*;?/, (_full, body: string) => {
+		const trimmedRight = body.replace(/\s*$/, '');
+		if (!trimmedRight.length) {
+			return `export default {\n\t${coreAliasEntry}\n};`;
+		}
+
+		const withComma = trimmedRight.endsWith(',') ? trimmedRight : `${trimmedRight},`;
+		return `export default {${withComma}\n\t${coreAliasEntry}\n};`;
+	});
+};
+
+export default async function createPresenterFactory(): Promise<void> {
+	const { presenterFactoryNameRaw } = await prompts({
+		type: 'text',
+		name: 'presenterFactoryNameRaw',
+		message: 'Presenter factory name:',
+		initial: 'AppPresenter'
+	});
+
+	const presenterFactoryName = toPascalCase(String(presenterFactoryNameRaw ?? 'AppPresenter')) || 'AppPresenter';
+	const presenterRootPath = path.join(process.cwd(), 'src', 'core', 'presenter');
+	const filePath = path.join(presenterRootPath, `${presenterFactoryName}.ts`);
+
+	await fs.mkdir(presenterRootPath, { recursive: true });
+
+	const created = await writeIfNotExists(filePath, createPresenterFactoryTemplate(presenterFactoryName));
+	if (!created) {
+		console.log(`⚠️ Presenter factory "${presenterFactoryName}" already exists. File was not overwritten.`);
+	} else {
+		await updateIndexTs(presenterRootPath);
+		console.log(`✅ Presenter factory created: ${filePath}`);
+	}
+
+	const { useAsDefault } = await prompts({
+		type: 'confirm',
+		name: 'useAsDefault',
+		message: 'Use this presenter factory as default for the project?',
+		initial: true
+	});
+
+	if (!useAsDefault) return;
+
+	const config = resolveConfigFile(process.cwd());
+	const nextContent = upsertDefaultPresenterFactoryConfig(config.content, presenterFactoryName);
+	await fs.writeFile(config.filepath, nextContent, 'utf-8');
+	console.log(`✅ Default presenter factory saved to ${path.basename(config.filepath)}`);
+}

package/src/scaffolds/createResponse.js

@@ -0,0 +1,64 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import prompts from 'prompts';
+import { writeIfNotExists, updateIndexTs } from '../utils/fileUtils.js';
+import { toPascalCase } from '../utils/contextUtils.js';
+
+const createResponseWithWrapperTemplate = (name) => {
+	const interfaceName = `I${name}`;
+	return `import { ResponseBuilder } from '@azure-net/kit/infra';
+
+export interface ${interfaceName}<T> {
+\tdata: T;
+}
+
+export class ${name}<TData = unknown, TMeta = unknown> extends ResponseBuilder<TData, TMeta, ${interfaceName}<TData>> {
+\tprotected unwrapData(data: ${interfaceName}<TData>): TData {
+\t\treturn data.data;
+\t}
+}
+`;
+};
+
+const createResponseSimpleTemplate = (name) => `import { ResponseBuilder } from '@azure-net/kit/infra';
+
+export class ${name}<TData = unknown, TMeta = unknown> extends ResponseBuilder<TData, TMeta> {}
+`;
+
+const ensureResponseName = (rawName) => {
+	const normalized = toPascalCase(rawName || 'ApiResponse') || 'ApiResponse';
+	return normalized.endsWith('Response') ? normalized : `${normalized}Response`;
+};
+
+export default async function createResponse() {
+	const { responseNameRaw } = await prompts({
+		type: 'text',
+		name: 'responseNameRaw',
+		message: 'Response class name:',
+		initial: 'ApiResponse'
+	});
+
+	const responseName = ensureResponseName(String(responseNameRaw ?? 'ApiResponse'));
+
+	const { useCommonResponseWrapper } = await prompts({
+		type: 'confirm',
+		name: 'useCommonResponseWrapper',
+		message: 'Use common backend response wrapper interface?',
+		initial: true
+	});
+
+	const responseRoot = path.join(process.cwd(), 'src', 'core', 'response');
+	const filePath = path.join(responseRoot, `${responseName}.ts`);
+	await fs.mkdir(responseRoot, { recursive: true });
+
+	const template = useCommonResponseWrapper ? createResponseWithWrapperTemplate(responseName) : createResponseSimpleTemplate(responseName);
+	const created = await writeIfNotExists(filePath, template);
+	await updateIndexTs(responseRoot);
+
+	if (!created) {
+		console.log(`⚠️ Response "${responseName}" already exists. File was not overwritten.`);
+		return;
+	}
+
+	console.log(`✅ Response created: ${filePath}`);
+}

package/src/scaffolds/createResponse.ts

@@ -0,0 +1,64 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import prompts from 'prompts';
+import { writeIfNotExists, updateIndexTs } from '../utils/fileUtils.js';
+import { toPascalCase } from '../utils/contextUtils.js';
+
+const createResponseWithWrapperTemplate = (name: string): string => {
+	const interfaceName = `I${name}`;
+	return `import { ResponseBuilder } from '@azure-net/kit/infra';
+
+export interface ${interfaceName}<T> {
+\tdata: T;
+}
+
+export class ${name}<TData = unknown, TMeta = unknown> extends ResponseBuilder<TData, TMeta, ${interfaceName}<TData>> {
+\tprotected unwrapData(data: ${interfaceName}<TData>): TData {
+\t\treturn data.data;
+\t}
+}
+`;
+};
+
+const createResponseSimpleTemplate = (name: string): string => `import { ResponseBuilder } from '@azure-net/kit/infra';
+
+export class ${name}<TData = unknown, TMeta = unknown> extends ResponseBuilder<TData, TMeta> {}
+`;
+
+const ensureResponseName = (rawName: string): string => {
+	const normalized = toPascalCase(rawName || 'ApiResponse') || 'ApiResponse';
+	return normalized.endsWith('Response') ? normalized : `${normalized}Response`;
+};
+
+export default async function createResponse(): Promise<void> {
+	const { responseNameRaw } = await prompts({
+		type: 'text',
+		name: 'responseNameRaw',
+		message: 'Response class name:',
+		initial: 'ApiResponse'
+	});
+
+	const responseName = ensureResponseName(String(responseNameRaw ?? 'ApiResponse'));
+
+	const { useCommonResponseWrapper } = await prompts({
+		type: 'confirm',
+		name: 'useCommonResponseWrapper',
+		message: 'Use common backend response wrapper interface?',
+		initial: true
+	});
+
+	const responseRoot = path.join(process.cwd(), 'src', 'core', 'response');
+	const filePath = path.join(responseRoot, `${responseName}.ts`);
+	await fs.mkdir(responseRoot, { recursive: true });
+
+	const template = useCommonResponseWrapper ? createResponseWithWrapperTemplate(responseName) : createResponseSimpleTemplate(responseName);
+	const created = await writeIfNotExists(filePath, template);
+	await updateIndexTs(responseRoot);
+
+	if (!created) {
+		console.log(`⚠️ Response "${responseName}" already exists. File was not overwritten.`);
+		return;
+	}
+
+	console.log(`✅ Response created: ${filePath}`);
+}

package/src/scaffolds/createSchemaRule.js

@@ -0,0 +1,40 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import prompts from 'prompts';
+import { writeIfNotExists, updateIndexTs } from '../utils/fileUtils.js';
+import { toPascalCase, toCamelCase } from '../utils/contextUtils.js';
+
+const createSchemaRuleTemplate = (ruleName) => `import type { ValidationParams, ValidationRuleResult } from '@azure-net/kit/delivery';
+
+export const ${ruleName} = <T = unknown, D = unknown>(): ValidationRuleResult<T, D> => {
+\treturn (validationParams: ValidationParams<T, D>) => {
+\t\treturn undefined;
+\t};
+};
+`;
+
+export default async function createSchemaRule() {
+	const { ruleNameRaw } = await prompts({
+		type: 'text',
+		name: 'ruleNameRaw',
+		message: 'Schema rule name:',
+		initial: 'File'
+	});
+
+	const pascalName = toPascalCase(String(ruleNameRaw ?? 'File')) || 'File';
+	const camelName = toCamelCase(pascalName) || 'file';
+	const rulesPath = path.join(process.cwd(), 'src', 'core', 'schema', 'custom-rules');
+	const filePath = path.join(rulesPath, `${pascalName}.ts`);
+
+	await fs.mkdir(rulesPath, { recursive: true });
+
+	const created = await writeIfNotExists(filePath, createSchemaRuleTemplate(camelName));
+	await updateIndexTs(rulesPath);
+
+	if (!created) {
+		console.log(`⚠️ Schema rule "${pascalName}" already exists. File was not overwritten.`);
+		return;
+	}
+
+	console.log(`✅ Schema rule created: ${filePath}`);
+}

package/src/scaffolds/createSchemaRule.ts

@@ -0,0 +1,42 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import prompts from 'prompts';
+import { writeIfNotExists, updateIndexTs } from '../utils/fileUtils.js';
+import { toPascalCase, toCamelCase } from '../utils/contextUtils.js';
+
+const createSchemaRuleTemplate = (
+	ruleName: string
+): string => `import type { ValidationParams, ValidationRuleResult } from '@azure-net/kit/delivery';
+
+export const ${ruleName} = <T = unknown, D = unknown>(): ValidationRuleResult<T, D> => {
+\treturn (validationParams: ValidationParams<T, D>) => {
+\t\treturn undefined;
+\t};
+};
+`;
+
+export default async function createSchemaRule(): Promise<void> {
+	const { ruleNameRaw } = await prompts({
+		type: 'text',
+		name: 'ruleNameRaw',
+		message: 'Schema rule name:',
+		initial: 'File'
+	});
+
+	const pascalName = toPascalCase(String(ruleNameRaw ?? 'File')) || 'File';
+	const camelName = toCamelCase(pascalName) || 'file';
+	const rulesPath = path.join(process.cwd(), 'src', 'core', 'schema', 'custom-rules');
+	const filePath = path.join(rulesPath, `${pascalName}.ts`);
+
+	await fs.mkdir(rulesPath, { recursive: true });
+
+	const created = await writeIfNotExists(filePath, createSchemaRuleTemplate(camelName));
+	await updateIndexTs(rulesPath);
+
+	if (!created) {
+		console.log(`⚠️ Schema rule "${pascalName}" already exists. File was not overwritten.`);
+		return;
+	}
+
+	console.log(`✅ Schema rule created: ${filePath}`);
+}

package/src/scaffolds/createTranslationManager.js

@@ -0,0 +1,78 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import prompts from 'prompts';
+import { writeIfNotExists } from '../utils/fileUtils.js';
+
+const parseLocales = (rawLocales) => {
+	const parsed = String(rawLocales ?? '')
+		.split(',')
+		.map((item) => item.trim().toLowerCase())
+		.filter(Boolean);
+
+	const unique = Array.from(new Set(parsed));
+	return unique.length ? unique : ['en', 'ru'];
+};
+
+const createTranslationIndexTemplate = (defaultLocale) => `import { messages } from './locales/index.js';
+import { createTranslations, type Path } from '@azure-net/kit/i18n';
+
+export const TranslationManager = createTranslations({
+\tmessages,
+\tinitLang: '${defaultLocale}',
+\tinitLangFromAcceptLanguage: true,
+\tcookieName: 'current-language'
+});
+
+type MessagesList = Awaited<ReturnType<(typeof messages)[keyof typeof messages]>>;
+type TranslationExtended = { key: MessageKeys | string; vars?: Record<string, unknown> };
+
+export type MessageKeys = Path<MessagesList>;
+export type TranslationParam = MessageKeys | string | TranslationExtended;
+export type AvailableLocales = keyof typeof messages;
+`;
+
+const createLocalesIndexTemplate = (locales) => {
+	const lines = locales.map((locale) => `\t${locale}: () => import('./${locale}/index.js').then((res) => res.default)`);
+	return `export const messages = {\n${lines.join(',\n')}\n};\n`;
+};
+
+const createLocaleTemplate = () => `export default {
+\ttest: 'test'
+};
+`;
+
+export default async function createTranslationManager() {
+	const { localesRaw } = await prompts({
+		type: 'text',
+		name: 'localesRaw',
+		message: 'Enter locales (comma separated):',
+		initial: 'en, ru'
+	});
+
+	const locales = parseLocales(String(localesRaw ?? 'en, ru'));
+
+	const { defaultLocale } = await prompts({
+		type: 'select',
+		name: 'defaultLocale',
+		message: 'Choose default locale:',
+		choices: locales.map((locale) => ({ title: locale, value: locale })),
+		initial: 0
+	});
+
+	const selectedDefaultLocale = String(defaultLocale ?? locales[0] ?? 'en');
+
+	const translationRoot = path.join(process.cwd(), 'src', 'core', 'translation');
+	const localesRoot = path.join(translationRoot, 'locales');
+	await fs.mkdir(localesRoot, { recursive: true });
+
+	await writeIfNotExists(path.join(translationRoot, 'index.ts'), createTranslationIndexTemplate(selectedDefaultLocale));
+	await writeIfNotExists(path.join(localesRoot, 'index.ts'), createLocalesIndexTemplate(locales));
+
+	for (const locale of locales) {
+		const localeDir = path.join(localesRoot, locale);
+		await fs.mkdir(localeDir, { recursive: true });
+		await writeIfNotExists(path.join(localeDir, 'index.ts'), createLocaleTemplate());
+	}
+
+	console.log(`✅ Translation manager created: ${translationRoot}`);
+}

package/src/scaffolds/createTranslationManager.ts

@@ -0,0 +1,78 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import prompts from 'prompts';
+import { writeIfNotExists } from '../utils/fileUtils.js';
+
+const parseLocales = (rawLocales: string): string[] => {
+	const parsed = String(rawLocales ?? '')
+		.split(',')
+		.map((item) => item.trim().toLowerCase())
+		.filter(Boolean);
+
+	const unique = Array.from(new Set(parsed));
+	return unique.length ? unique : ['en', 'ru'];
+};
+
+const createTranslationIndexTemplate = (defaultLocale: string): string => `import { messages } from './locales/index.js';
+import { createTranslations, type Path } from '@azure-net/kit/i18n';
+
+export const TranslationManager = createTranslations({
+\tmessages,
+\tinitLang: '${defaultLocale}',
+\tinitLangFromAcceptLanguage: true,
+\tcookieName: 'current-language'
+});
+
+type MessagesList = Awaited<ReturnType<(typeof messages)[keyof typeof messages]>>;
+type TranslationExtended = { key: MessageKeys | string; vars?: Record<string, unknown> };
+
+export type MessageKeys = Path<MessagesList>;
+export type TranslationParam = MessageKeys | string | TranslationExtended;
+export type AvailableLocales = keyof typeof messages;
+`;
+
+const createLocalesIndexTemplate = (locales: string[]): string => {
+	const lines = locales.map((locale) => `\t${locale}: () => import('./${locale}/index.js').then((res) => res.default)`);
+	return `export const messages = {\n${lines.join(',\n')}\n};\n`;
+};
+
+const createLocaleTemplate = (): string => `export default {
+\ttest: 'test'
+};
+`;
+
+export default async function createTranslationManager(): Promise<void> {
+	const { localesRaw } = await prompts({
+		type: 'text',
+		name: 'localesRaw',
+		message: 'Enter locales (comma separated):',
+		initial: 'en, ru'
+	});
+
+	const locales = parseLocales(String(localesRaw ?? 'en, ru'));
+
+	const { defaultLocale } = await prompts({
+		type: 'select',
+		name: 'defaultLocale',
+		message: 'Choose default locale:',
+		choices: locales.map((locale) => ({ title: locale, value: locale })),
+		initial: 0
+	});
+
+	const selectedDefaultLocale = String(defaultLocale ?? locales[0] ?? 'en');
+
+	const translationRoot = path.join(process.cwd(), 'src', 'core', 'translation');
+	const localesRoot = path.join(translationRoot, 'locales');
+	await fs.mkdir(localesRoot, { recursive: true });
+
+	await writeIfNotExists(path.join(translationRoot, 'index.ts'), createTranslationIndexTemplate(selectedDefaultLocale));
+	await writeIfNotExists(path.join(localesRoot, 'index.ts'), createLocalesIndexTemplate(locales));
+
+	for (const locale of locales) {
+		const localeDir = path.join(localesRoot, locale);
+		await fs.mkdir(localeDir, { recursive: true });
+		await writeIfNotExists(path.join(localeDir, 'index.ts'), createLocaleTemplate());
+	}
+
+	console.log(`✅ Translation manager created: ${translationRoot}`);
+}

package/src/scaffolds/index.js

@@ -0,0 +1,9 @@
+export { default as createCoreSchema } from './createCoreSchema.js';
+export { default as createCoreMiddleware } from './createCoreMiddleware.js';
+export { default as createTranslationManager } from './createTranslationManager.js';
+export { default as createPresenterFactory } from './createPresenterFactory.js';
+export { default as createSchemaRule } from './createSchemaRule.js';
+export { default as createMiddleware } from './createMiddleware.js';
+export { default as createResponse } from './createResponse.js';
+export { default as createDatasource } from './createDatasource.js';
+export { default as createDatasourceProvider } from './createDatasourceProvider.js';

package/src/scaffolds/index.ts

@@ -0,0 +1,9 @@
+export { default as createCoreSchema } from './createCoreSchema.js';
+export { default as createCoreMiddleware } from './createCoreMiddleware.js';
+export { default as createTranslationManager } from './createTranslationManager.js';
+export { default as createPresenterFactory } from './createPresenterFactory.js';
+export { default as createSchemaRule } from './createSchemaRule.js';
+export { default as createMiddleware } from './createMiddleware.js';
+export { default as createResponse } from './createResponse.js';
+export { default as createDatasource } from './createDatasource.js';
+export { default as createDatasourceProvider } from './createDatasourceProvider.js';

package/src/utils/contextUtils.js

@@ -6,76 +6,83 @@ import { loadUserConfig } from './loadConfig.js';
 const APP_PATH = path.join(process.cwd(), 'src/app');
 const CORE_PATH = path.join(process.cwd(), 'src/core');
 
+function normalizeContextNames(rawContexts) {
+	if (!Array.isArray(rawContexts)) return [];
+
+	return rawContexts
+		.map((item) => {
+			if (typeof item === 'string') {
+				return item.trim();
+			}
+			if (!item || typeof item !== 'object') return '';
+			return String(item.name ?? '').trim();
+		})
+		.filter(Boolean);
+}
+
 export async function selectContext(message = 'Select context:') {
-    const config = await loadUserConfig();
-    const contexts = config.contexts || ['app'];
+	const config = await loadUserConfig();
+	const contexts = normalizeContextNames(config.contexts);
 
-    const { context } = await prompts({
-        type: 'select',
-        name: 'context',
-        message,
-        choices: [
-            ...contexts.map(c => ({ title: c, value: c })),
-            { title: 'core', value: 'core' }
-        ]
-    });
+	const { context } = await prompts({
+		type: 'select',
+		name: 'context',
+		message,
+		choices: [...contexts.map((c) => ({ title: c, value: c })), { title: 'core', value: 'core' }]
+	});
 
-    return context;
+	return context;
 }
 
 export function getContextPath(context) {
-    return context === 'core'
-        ? CORE_PATH
-        : path.join(APP_PATH, context, 'layers');
+	return context === 'core' ? CORE_PATH : path.join(APP_PATH, context, 'layers');
 }
 
 export async function getAvailableFiles(dir, pattern = '.ts') {
-    try {
-        const files = await fs.readdir(dir);
-        return files
-            .filter(f => f.endsWith(pattern) && f !== 'index.ts')
-            .map(f => f.replace(pattern, ''));
-    } catch {
-        return [];
-    }
+	try {
+		const files = await fs.readdir(dir);
+		return files.filter((f) => f.endsWith(pattern) && f !== 'index.ts').map((f) => f.replace(pattern, ''));
+	} catch {
+		return [];
+	}
 }
 
 export async function getApplicationProviderServices(context) {
-    const contextPath = getContextPath(context);
-    const providerPath = path.join(contextPath, 'application/providers/ApplicationProvider.ts');
+	const contextPath = getContextPath(context);
+	const providerPath = path.join(contextPath, 'application/providers/ApplicationProvider.ts');
 
-    try {
-        const content = await fs.readFile(providerPath, 'utf-8');
-        // Extract service names from ApplicationProvider
-        const serviceRegex = /(\w+Service):\s*\(/g;
-        const services = [];
-        let match;
+	try {
+		const content = await fs.readFile(providerPath, 'utf-8');
+		// Extract service names from ApplicationProvider
+		const serviceRegex = /(\w+Service):\s*\(/g;
+		const services = [];
+		let match;
 
-        while ((match = serviceRegex.exec(content)) !== null) {
-            services.push(match[1]);
-        }
+		while ((match = serviceRegex.exec(content)) !== null) {
+			services.push(match[1]);
+		}
 
-        return services;
-    } catch {
-        return [];
-    }
+		return services;
+	} catch {
+		return [];
+	}
 }
 
 export function toPascalCase(str) {
-    return str
-        .split(/[-_\s]+/)
-        .map(word => word.charAt(0).toUpperCase() + word.slice(1))
-        .join('');
+	return str
+		.split(/[-_\s]+/)
+		.map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+		.join('');
 }
 
 export function toCamelCase(str) {
-    const pascal = toPascalCase(str);
-    return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+	const pascal = toPascalCase(str);
+	return pascal.charAt(0).toLowerCase() + pascal.slice(1);
 }
 
 export function toKebabCase(str) {
-    return str
-        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
-        .replace(/([A-Z])([A-Z][a-z])/g, '$1-$2')
-        .toLowerCase();
-}
+	return str
+		.replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+		.replace(/([A-Z])([A-Z][a-z])/g, '$1-$2')
+		.toLowerCase();
+}