@breadstone-infrastructure/nx-tasks 0.0.256 → 0.0.258

package/src/executors/ng-proxy-transform/executor.ts

@@ -0,0 +1,49 @@
+// #region Imports
+
+import { Path } from '@breadstone-infrastructure/utilities';
+import type { ExecutorContext } from '@nx/devkit';
+import { getProjectPackageJson } from '../../utils/getProjectPackageJson';
+import { getProjectRoot } from '../../utils/getProjectRoot';
+import { getProjectTsConfigJson } from '../../utils/getProjectTsConfigJson';
+import { isVerbose } from '../../utils/isVerbose';
+import type { NgProxyTransformTask } from './executor.task';
+
+// #endregion
+
+/**
+ * @public
+ */
+export type NgProxyTransformExecutorOptions = Omit<NgProxyTransformTask.INgProxyTransformTaskOptions, 'cwd' | 'tsConfigJson' | 'packageJson'>;
+
+/**
+ * @public
+ */
+export default async function runExecutor(options: NgProxyTransformExecutorOptions, context: ExecutorContext): Promise<{ success: boolean }> {
+    try {
+        const task = (await import('./executor.task')).NgProxyTransformTask;
+
+        await task.run({
+            cwd: getProjectRoot(context),
+            packageJson: getProjectPackageJson(context),
+            tsConfigJson: getProjectTsConfigJson(context),
+            out: options.out,
+            path: options.path,
+            standalone: options.standalone,
+            verbose: isVerbose(context, options),
+            aliases: options.aliases,
+            controlValueAccessors: options.controlValueAccessors,
+            intlProviders: options.intlProviders,
+            cleanOut: options.cleanOut,
+            ignore: options.ignore,
+            additionalExports: options.additionalExports,
+            cache: {
+                enabled: options.cache?.enabled ?? context.target?.cache ?? false,
+                dirPath: Path.combine(getProjectRoot(context), '.cache')
+            }
+        });
+        return { success: true };
+    } catch (error) {
+        console.error(error);
+        return { success: false };
+    }
+}

package/src/executors/ng-proxy-transform/schema.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "https://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "intlProviders": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "description": "List of custom element tag names that provide intl support. For these elements, the generated Angular proxy will use a Partial<> typed input signal for intl and sync via Object.assign instead of direct assignment."
+    }
+  }
+}

package/src/executors/openapi-generator/executor.task.ts

@@ -0,0 +1,43 @@
+// #region Imports
+
+import { ConsoleLogger, logSeparator } from '@breadstone-infrastructure/utilities';
+import { run as openapi, type IRunConfig } from '@breadstone-tools/openapi-app';
+
+// #endregion
+
+export namespace ApiGeneratorTask {
+
+    export interface IApiGeneratorTaskOptions {
+        cwd: IRunConfig['cwd'];
+        output: IRunConfig['output'];
+        endpoints?: IRunConfig['endpoints'];
+        parser?: IRunConfig['parser'];
+        debug?: IRunConfig['debug'];
+        dryRun?: IRunConfig['dryRun'];
+        cleanRun?: IRunConfig['clearRun'];
+        templates?: IRunConfig['templates'];
+        quiet?: IRunConfig['quiet'];
+    }
+
+    export async function run(options: IApiGeneratorTaskOptions): Promise<void> {
+        const logger = new ConsoleLogger();
+
+        logSeparator(logger, 'Api Generator');
+
+        const result = await openapi({
+            cwd: options.cwd,
+            output: options.output,
+            endpoints: options.endpoints,
+            parser: options.parser,
+            debug: options.debug,
+            dryRun: options.dryRun,
+            clearRun: options.cleanRun,
+            templates: options.templates,
+            quiet: options.quiet
+        });
+
+        logger.log(`Files generated to '${result.target}'.`);
+
+        logSeparator(logger);
+    }
+}

package/src/executors/openapi-generator/executor.ts

@@ -0,0 +1,35 @@
+
+// #region Imports
+
+import type { ExecutorContext } from '@nx/devkit';
+import { getProjectRoot } from '../../utils/getProjectRoot';
+import type { ApiGeneratorTask } from './executor.task';
+
+// #endregion
+
+type ExecutorOptions = Omit<ApiGeneratorTask.IApiGeneratorTaskOptions, 'cwd' | 'packageJson' | 'tsConfigJson'>;
+
+/**
+ * @public
+ */
+export default async function runExecutor(options: ExecutorOptions, context: ExecutorContext): Promise<{ success: boolean }> {
+    try {
+        const task = (await import('./executor.task')).ApiGeneratorTask;
+
+        await task.run({
+            cwd: getProjectRoot(context),
+            output: options.output,
+            debug: options.debug,
+            dryRun: options.dryRun,
+            cleanRun: options.cleanRun,
+            endpoints: options.endpoints,
+            parser: options.parser,
+            templates: options.templates,
+            quiet: options.quiet
+        });
+        return { success: true };
+    } catch (error) {
+        console.error(error);
+        return { success: false };
+    }
+}

package/src/executors/openapi-generator/schema.json

@@ -0,0 +1 @@
+{}

package/src/executors/prisma-seeds/executor.options.ts

@@ -0,0 +1,15 @@
+/**
+ * @description Options for the prisma-seeds executor as declared in project.json.
+ * All fields are optional - the primary config comes from `seed.config.mjs`.
+ * Any options specified here override the config file values.
+ * @public
+ */
+export interface PrismaSeedsExecutorOptions {
+    drop?: boolean;
+    count?: number;
+    force?: boolean;
+    dryRun?: boolean;
+    seed?: number;
+    environment?: string;
+    verbose?: boolean;
+}

package/src/executors/prisma-seeds/executor.task.ts

@@ -0,0 +1,63 @@
+// #region Imports
+
+import { SeedOrchestrator } from '@breadstone-infrastructure/prisma-seeds';
+
+// #endregion
+
+/**
+ * @description Task to discover and execute Prisma seed configurations.
+ * Discovers `seed.config.mjs` in the project root automatically.
+ * Executor options from project.json override the config file values.
+ * @public
+ */
+export namespace PrismaSeedsTask {
+
+    // #region Interfaces
+
+    /**
+     * @description All fields are optional - the primary configuration comes from
+     * the `seed.config.mjs` config file. Any values provided here override
+     * the config file values.
+     * @public
+     */
+    export interface IPrismaSeedsTaskOptions {
+        cwd: string;
+        drop?: boolean;
+        count?: number;
+        force?: boolean;
+        dryRun?: boolean;
+        seed?: number;
+        environment?: string;
+    }
+
+    // #endregion
+
+    // #region Functions
+
+    /**
+     * @description Discovers the config file and executes the Prisma seeder.
+     * Executor options override config file values.
+     */
+    export async function run(options: IPrismaSeedsTaskOptions): Promise<void> {
+        const orchestrator = new SeedOrchestrator();
+        const overrides: Record<string, unknown> = {};
+
+        if (options.drop !== undefined) { overrides['drop'] = options.drop; }
+        if (options.count !== undefined) { overrides['count'] = options.count; }
+        if (options.force !== undefined) { overrides['force'] = options.force; }
+        if (options.dryRun !== undefined) { overrides['dryRun'] = options.dryRun; }
+        if (options.seed !== undefined) { overrides['seed'] = options.seed; }
+        if (options.environment !== undefined) { overrides['environment'] = options.environment; }
+
+        const result = await orchestrator.executeWithOverrides(options.cwd, overrides);
+
+        if (!result.success) {
+            const errorMessages = result.errors.length > 0
+                ? result.errors.join('\n')
+                : 'Unknown error';
+            throw new Error(`Prisma Seeder failed:\n${errorMessages}`);
+        }
+    }
+
+    // #endregion
+}

package/src/executors/prisma-seeds/executor.ts

@@ -0,0 +1,39 @@
+// #region Imports
+
+import type { ExecutorContext } from '@nx/devkit';
+import { getProjectRoot } from '../../utils/getProjectRoot';
+import { isVerbose } from '../../utils/isVerbose';
+import type { PrismaSeedsExecutorOptions } from './executor.options';
+
+// #endregion
+
+/**
+ * @description Nx executor entry point for prisma-seeds.
+ * @public
+ */
+export default async function runExecutor(options: PrismaSeedsExecutorOptions, context: ExecutorContext): Promise<{ success: boolean }> {
+    try {
+        const task = (await import('./executor.task')).PrismaSeedsTask;
+        const verbose = isVerbose(context, options);
+
+        if (verbose) {
+            console.log('Prisma Seeds executor started with options:', JSON.stringify(options, undefined, 2));
+        }
+
+        await task.run({
+            cwd: getProjectRoot(context),
+            drop: options.drop,
+            count: options.count,
+            force: options.force,
+            dryRun: options.dryRun,
+            seed: options.seed,
+            environment: options.environment,
+        });
+
+        return { success: true };
+    } catch (error) {
+        console.error(error);
+
+        return { success: false };
+    }
+}

package/src/executors/prisma-seeds/schema.json

@@ -0,0 +1,35 @@
+{
+  "type": "object",
+  "description": "Prisma seeds executor options. All fields are optional \u2014 the primary config comes from `seed.config.mjs` in the project root. Options specified here override the config file values.",
+  "properties": {
+    "drop": {
+      "type": "boolean",
+      "description": "Drop existing data before seeding. Overrides config file."
+    },
+    "count": {
+      "type": "number",
+      "description": "Number of items to seed per definition. Overrides config file."
+    },
+    "force": {
+      "type": "boolean",
+      "description": "Force seeding even if data already exists. Overrides config file."
+    },
+    "dryRun": {
+      "type": "boolean",
+      "description": "Run without making changes to the database. Overrides config file."
+    },
+    "seed": {
+      "type": "number",
+      "description": "Seed value for deterministic random number generation. Overrides config file."
+    },
+    "environment": {
+      "type": "string",
+      "description": "Target environment name (e.g., 'development', 'staging'). Overrides config file."
+    },
+    "verbose": {
+      "type": "boolean",
+      "description": "Enable verbose logging. Overrides config file."
+    }
+  },
+  "required": []
+}

package/src/executors/react-proxy-transform/executor.task.ts

@@ -0,0 +1,243 @@
+// #region Imports
+
+import { blue, ConsoleLogger, CustomElementManifest, File, gray, green, type IFileCacheOptions, logSeparator, Path, StringExtensions } from '@breadstone-infrastructure/utilities';
+import prettier from 'prettier';
+import type { PackageJson, TsConfigJson } from 'type-fest';
+import { withCaching } from '../../utils/withCaching';
+
+// #endregion
+
+export namespace ReactProxyTransformTask {
+
+    export const DEFAULT_OPTIONS = {
+        standalone: false,
+        verbose: false,
+        cleanOut: false,
+        aliases: {},
+        ignore: [],
+        prettier: {
+            arrowParens: 'always',
+            bracketSameLine: false,
+            bracketSpacing: true,
+            semi: true,
+            experimentalTernaries: true,
+            singleQuote: true,
+            jsxSingleQuote: false,
+            quoteProps: 'as-needed',
+            trailingComma: 'none',
+            singleAttributePerLine: false,
+            proseWrap: 'never',
+            insertPragma: false,
+            requirePragma: false,
+            tabWidth: 4,
+            useTabs: false,
+            embeddedLanguageFormatting: 'auto',
+            printWidth: 1200
+        } satisfies prettier.Config
+    };
+
+    export interface IReactProxyTransformOptions {
+        cwd: string;
+        path: string;
+        out: string;
+        cleanOut?: boolean;
+        packageJson: PackageJson;
+        tsConfigJson: TsConfigJson;
+        verbose?: boolean;
+        aliases?: Record<string, string>;
+        ignore?: Array<string>;
+        cache?: IFileCacheOptions;
+    }
+
+    export async function run(options: IReactProxyTransformOptions): Promise<void> {
+        const logger = new ConsoleLogger();
+
+        logSeparator(logger, 'Transforming react proxy');
+
+        const fileCache = withCaching(options.cache);
+
+        // TODO: remove this when wca is not longer used.
+        // this happend when jsom2 is used as format; afterwards text files will be created.
+        // we have to change the extension to agian to json
+        const textFiles = File.glob(Path.combine(options.cwd, options.path, '**/*.txt'));
+        textFiles.forEach((file) => {
+            const content = File.readAllText(file);
+            File.writeAllText(file.replace('.txt', '.json'), content);
+            File.delete(file);
+        });
+
+        const filesPath = Path.combine(options.cwd, options.path, '**/*.json');
+        const files = File.glob(filesPath);
+        const createdFiles = new Array<string>();
+
+        if (options.verbose) {
+            logger.log(gray(`    Search for: ${filesPath}`));
+        }
+
+        if (files.length) {
+            if (options.verbose) {
+                logger.log(gray(`    ${files.length} files to transform`));
+            }
+
+            for (const file of files) {
+                // eslint-disable-next-line no-await-in-loop
+                if (!await fileCache.isFileCached(file)) {
+                    try {
+                        const doc = File.readAllJson(file) as unknown as CustomElementManifest.PackageDoc;
+                        const def = CustomElementManifest.readDefinition(doc);
+                        const properties = CustomElementManifest.readProperties(doc);
+                        const methods = CustomElementManifest.readMethods(doc);
+                        const events = CustomElementManifest.readEvents(doc);
+                        const out = getOutPathAndFile(def.declaration.module ?? '');
+
+                        // eslint-disable-next-line max-depth
+                        if (options.ignore?.includes(def.name)) {
+                            // eslint-disable-next-line max-depth
+                            if (options.verbose) {
+                                logger.log(gray(`    [IGNORE] ${Path.relative(options.cwd, file)}`));
+                            }
+
+                            continue;
+                        }
+
+                        const rootDir = options.tsConfigJson.compilerOptions?.rootDir ?? '';
+                        const outPath = Path.combine(options.cwd, options.out, out ?? '');
+                        const utilsPath = Path.combine(options.cwd, 'src/utils/Proxy.ts');
+                        const relativeUtilsPath = Path.relative(Path.getDirectoryName(outPath), utilsPath);
+
+                        Path.relative(options.cwd, rootDir);
+                        let result = createReactComponentDefinition(relativeUtilsPath, def.name, properties.map((x) => x.name), events.map((x) => x.name), methods.map((x) => x.name), options.aliases ?? {});
+
+                        // eslint-disable-next-line no-await-in-loop
+                        result = await formatTypeScript(result);
+                        const outFileExists = File.exists(outPath);
+
+                        File.writeAllText(outPath, result);
+                        createdFiles.push(Path.relative(options.cwd, outPath));
+
+                        // eslint-disable-next-line max-depth
+                        if (outFileExists) {
+                            logger.log(`    ${blue('[UPDATE]')} ${out}`);
+                        } else {
+                            logger.log(`    ${green('[CREATE]')} ${out}`);
+                        }
+                    } catch (error) {
+                        logger.error('    Error while transforming.');
+                        logger.error(`    ${error}`);
+                    }
+                } else if (options.verbose) {
+                    logger.log(gray(`    File ${Path.relative(options.cwd, file)} is up to date.`));
+                }
+            }
+
+            try {
+                const indexExports = createReactIndexExports(createdFiles);
+                const outPath = Path.combine(options.cwd, options.out, 'Index.ts');
+                const formatted = await formatTypeScript(indexExports);
+                File.writeAllText(outPath, formatted);
+                logger.log(`    ${blue('[CREATE]')} Index.ts`);
+            } catch (error) {
+                logger.error('Error while transforming.');
+                logger.error(`${error}`);
+            }
+        } else {
+            logger.log(gray('\tFile or Folder is up to date.'));
+        }
+
+        logSeparator(logger);
+
+        return Promise.resolve();
+    }
+
+    function formatTypeScript(code: string): Promise<string> {
+        return prettier.format(code, {
+            parser: 'typescript',
+            ...DEFAULT_OPTIONS.prettier
+        });
+    }
+
+}
+
+/**
+ * Creates an react component declaration from formatted Stencil compiler metadata.
+ *
+ * @param tagName The tag name of the component.
+ * @param inputs The inputs of the Stencil component (e.g. ['myInput']).
+ * @param outputs The outputs/events of the Stencil component. (e.g. ['myOutput']).
+ * @param methods The methods of the Stencil component. (e.g. ['myMethod']).
+ * @param includeImportCustomElements Whether to define the component as a custom element.
+ * @param standalone Whether to define the component as a standalone component.
+ * @returns The component declaration as a string.
+ */
+const createReactComponentDefinition = (rootPath: string, tagName: string, inputs: ReadonlyArray<string>, outputs: ReadonlyArray<string>, methods: ReadonlyArray<string>, aliases: Record<string, string>): string => {
+    const tagNameAsPascal = dashToPascalCase(tagName);
+    const lookupName: string | null = Object.keys(aliases).includes(tagName) ? aliases[tagName] : null;
+    const controlNameWithoutSuffix = lookupName ?? tagNameAsPascal.replace('Mosaik', '');
+
+    /**
+     * Notes on the generated output:
+     * - We disable @angular-eslint/no-inputs-metadata-property, so that
+     * Angular does not complain about the inputs property. The output target
+     * uses the inputs property to define the inputs of the component instead of
+     * having to use the @Input decorator (and manually define the type and default value).
+     */
+    const output = `
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+
+// #region Imports
+
+import React from 'react';
+import { createComponent } from "${rootPath.replace('.ts', '').replace('utils', 'Utils')}";
+import { ${controlNameWithoutSuffix.concat('Element')} } from '@breadstone/mosaik-elements-foundation';
+
+// #endregion
+
+/**
+ * @public
+ */
+export const ${tagNameAsPascal.replace('Mosaik', '')} = createComponent({
+    tagName: '${tagName}',
+    displayName: '${tagNameAsPascal.replace('Mosaik', '')}',
+    elementClass: ${controlNameWithoutSuffix.concat('Element')},
+    react: React,
+    events: {
+        ${outputs.map((x): string => `on${StringExtensions.firstCharToUpperCase(x)}: '${x}'`).join(',\n        ')}
+    }
+});
+
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            '${tagName}':
+            | React.DetailedHTMLProps<
+                React.HTMLAttributes<${controlNameWithoutSuffix.concat('Element')}>,
+                ${controlNameWithoutSuffix.concat('Element')}
+                >
+            | Partial<${controlNameWithoutSuffix.concat('Element')}>;
+        }
+    }
+}
+
+`;
+
+    return output;
+};
+
+const createReactIndexExports = (componentTagNames: Array<string>): string => componentTagNames
+    .map((x) => Path.combine(Path.getDirectoryName(x), Path.getFileNameWithoutExtension(x)))
+    .map((x) => x.split('src/').pop())
+    .map((x) => `export * from './${x}';`)
+    .join('\n');
+
+const dashToPascalCase = (str: string): string => str.toLowerCase()
+    .split('-')
+    .map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1))
+    .join('');
+
+const getOutPathAndFile = (original: string): string | undefined => original.split('/src').pop()
+    ?.replace('Element.ts', 'Component.tsx');

package/src/executors/react-proxy-transform/executor.ts

@@ -0,0 +1,45 @@
+// #region Imports
+
+import { Path } from '@breadstone-infrastructure/utilities';
+import type { ExecutorContext } from '@nx/devkit';
+import { getProjectPackageJson } from '../../utils/getProjectPackageJson';
+import { getProjectRoot } from '../../utils/getProjectRoot';
+import { getProjectTsConfigJson } from '../../utils/getProjectTsConfigJson';
+import { isVerbose } from '../../utils/isVerbose';
+import type { ReactProxyTransformTask } from './executor.task';
+
+// #endregion
+
+/**
+ * @public
+ */
+export type ReactProxyTransformExecutorOptions = Omit<ReactProxyTransformTask.IReactProxyTransformOptions, 'cwd' | 'tsConfigJson' | 'packageJson'>;
+
+/**
+ * @public
+ */
+export default async function runExecutor(options: ReactProxyTransformExecutorOptions, context: ExecutorContext): Promise<{ success: boolean }> {
+    try {
+        const task = (await import('./executor.task')).ReactProxyTransformTask;
+
+        await task.run({
+            cwd: getProjectRoot(context),
+            packageJson: getProjectPackageJson(context),
+            tsConfigJson: getProjectTsConfigJson(context),
+            out: options.out,
+            path: options.path,
+            verbose: isVerbose(context, options),
+            aliases: options.aliases,
+            cleanOut: options.cleanOut,
+            ignore: options.ignore,
+            cache: {
+                enabled: options.cache?.enabled ?? context.target?.cache ?? false,
+                dirPath: Path.combine(getProjectRoot(context), '.cache')
+            }
+        });
+        return { success: true };
+    } catch (error) {
+        console.error(error);
+        return { success: false };
+    }
+}

package/src/executors/react-proxy-transform/schema.json

@@ -0,0 +1 @@
+{}