@geekmidas/cli 0.10.0 → 0.13.0

package/src/generators/FunctionGenerator.ts

@@ -4,102 +4,102 @@ import { Function } from '@geekmidas/constructs/functions';
 import type { BuildContext } from '../build/types';
 import type { FunctionInfo } from '../types';
 import {
-  ConstructGenerator,
-  type GeneratedConstruct,
-  type GeneratorOptions,
+	ConstructGenerator,
+	type GeneratedConstruct,
+	type GeneratorOptions,
 } from './Generator';
 
 export class FunctionGenerator extends ConstructGenerator<
-  Function<any, any, any, any, any, any, any, any, any, any, any, any>,
-  FunctionInfo[]
+	Function<any, any, any, any, any, any, any, any, any, any, any, any>,
+	FunctionInfo[]
 > {
-  isConstruct(
-    value: any,
-  ): value is Function<
-    any,
-    any,
-    any,
-    any,
-    any,
-    any,
-    any,
-    any,
-    any,
-    any,
-    any,
-    any
-  > {
-    return Function.isFunction(value);
-  }
+	isConstruct(
+		value: any,
+	): value is Function<
+		any,
+		any,
+		any,
+		any,
+		any,
+		any,
+		any,
+		any,
+		any,
+		any,
+		any,
+		any
+	> {
+		return Function.isFunction(value);
+	}
 
-  async build(
-    context: BuildContext,
-    constructs: GeneratedConstruct<
-      Function<any, any, any, any, any, any, any, any, any, any, any, any>
-    >[],
-    outputDir: string,
-    options?: GeneratorOptions,
-  ): Promise<FunctionInfo[]> {
-    const provider = options?.provider || 'aws-lambda';
-    const logger = console;
-    const functionInfos: FunctionInfo[] = [];
+	async build(
+		context: BuildContext,
+		constructs: GeneratedConstruct<
+			Function<any, any, any, any, any, any, any, any, any, any, any, any>
+		>[],
+		outputDir: string,
+		options?: GeneratorOptions,
+	): Promise<FunctionInfo[]> {
+		const provider = options?.provider || 'aws-lambda';
+		const logger = console;
+		const functionInfos: FunctionInfo[] = [];
 
-    if (constructs.length === 0 || provider !== 'aws-lambda') {
-      return functionInfos;
-    }
+		if (constructs.length === 0 || provider !== 'aws-lambda') {
+			return functionInfos;
+		}
 
-    // Create functions subdirectory
-    const functionsDir = join(outputDir, 'functions');
-    await mkdir(functionsDir, { recursive: true });
+		// Create functions subdirectory
+		const functionsDir = join(outputDir, 'functions');
+		await mkdir(functionsDir, { recursive: true });
 
-    // Generate function handlers
-    for (const { key, construct, path } of constructs) {
-      const handlerFile = await this.generateFunctionHandler(
-        functionsDir,
-        path.relative,
-        key,
-        context,
-      );
+		// Generate function handlers
+		for (const { key, construct, path } of constructs) {
+			const handlerFile = await this.generateFunctionHandler(
+				functionsDir,
+				path.relative,
+				key,
+				context,
+			);
 
-      functionInfos.push({
-        name: key,
-        handler: relative(process.cwd(), handlerFile).replace(
-          /\.ts$/,
-          '.handler',
-        ),
-        timeout: construct.timeout,
-        memorySize: construct.memorySize,
-        environment: await construct.getEnvironment(),
-      });
+			functionInfos.push({
+				name: key,
+				handler: relative(process.cwd(), handlerFile).replace(
+					/\.ts$/,
+					'.handler',
+				),
+				timeout: construct.timeout,
+				memorySize: construct.memorySize,
+				environment: await construct.getEnvironment(),
+			});
 
-      logger.log(`Generated function handler: ${key}`);
-    }
+			logger.log(`Generated function handler: ${key}`);
+		}
 
-    return functionInfos;
-  }
+		return functionInfos;
+	}
 
-  private async generateFunctionHandler(
-    outputDir: string,
-    sourceFile: string,
-    exportName: string,
-    context: BuildContext,
-  ): Promise<string> {
-    const handlerFileName = `${exportName}.ts`;
-    const handlerPath = join(outputDir, handlerFileName);
+	private async generateFunctionHandler(
+		outputDir: string,
+		sourceFile: string,
+		exportName: string,
+		context: BuildContext,
+	): Promise<string> {
+		const handlerFileName = `${exportName}.ts`;
+		const handlerPath = join(outputDir, handlerFileName);
 
-    const relativePath = relative(dirname(handlerPath), sourceFile);
-    const importPath = relativePath.replace(/\.ts$/, '.js');
+		const relativePath = relative(dirname(handlerPath), sourceFile);
+		const importPath = relativePath.replace(/\.ts$/, '.js');
 
-    const relativeEnvParserPath = relative(
-      dirname(handlerPath),
-      context.envParserPath,
-    );
-    const relativeLoggerPath = relative(
-      dirname(handlerPath),
-      context.loggerPath,
-    );
+		const relativeEnvParserPath = relative(
+			dirname(handlerPath),
+			context.envParserPath,
+		);
+		const relativeLoggerPath = relative(
+			dirname(handlerPath),
+			context.loggerPath,
+		);
 
-    const content = `import { AWSLambdaFunction } from '@geekmidas/constructs/functions';
+		const content = `import { AWSLambdaFunction } from '@geekmidas/constructs/functions';
 import { ${exportName} } from '${importPath}';
 import ${context.envParserImportPattern} from '${relativeEnvParserPath}';
 import ${context.loggerImportPattern} from '${relativeLoggerPath}';
@@ -109,7 +109,7 @@ const adapter = new AWSLambdaFunction(envParser, ${exportName});
 export const handler = adapter.handler;
 `;
 
-    await writeFile(handlerPath, content);
-    return handlerPath;
-  }
+		await writeFile(handlerPath, content);
+		return handlerPath;
+	}
 }

package/src/generators/Generator.ts

@@ -1,4 +1,4 @@
-import { relative } from 'path';
+import { relative } from 'node:path';
 import type { Construct } from '@geekmidas/constructs';
 import fg from 'fast-glob';
 import kebabCase from 'lodash.kebabcase';
@@ -6,90 +6,90 @@ import type { BuildContext } from '../build/types';
 import type { LegacyProvider, Routes } from '../types';
 
 export interface GeneratorOptions {
-  provider?: LegacyProvider;
-  [key: string]: any;
+	provider?: LegacyProvider;
+	[key: string]: any;
 }
 
 export abstract class ConstructGenerator<T extends Construct, R = void> {
-  abstract isConstruct(value: any): value is T;
+	abstract isConstruct(value: any): value is T;
 
-  static async build<T extends Construct, R = void>(
-    context: BuildContext,
-    outputDir: string,
-    generator: ConstructGenerator<T, R>,
-    patterns?: Routes,
-    options?: GeneratorOptions,
-  ): Promise<R> {
-    const constructs = await generator.load(patterns);
-    return generator.build(context, constructs, outputDir, options);
-  }
+	static async build<T extends Construct, R = void>(
+		context: BuildContext,
+		outputDir: string,
+		generator: ConstructGenerator<T, R>,
+		patterns?: Routes,
+		options?: GeneratorOptions,
+	): Promise<R> {
+		const constructs = await generator.load(patterns);
+		return generator.build(context, constructs, outputDir, options);
+	}
 
-  abstract build(
-    context: BuildContext,
-    constructs: GeneratedConstruct<T>[],
-    outputDir: string,
-    options?: GeneratorOptions,
-  ): Promise<R>;
+	abstract build(
+		context: BuildContext,
+		constructs: GeneratedConstruct<T>[],
+		outputDir: string,
+		options?: GeneratorOptions,
+	): Promise<R>;
 
-  async load(
-    patterns?: Routes,
-    cwd = process.cwd(),
-  ): Promise<GeneratedConstruct<T>[]> {
-    const logger = console;
+	async load(
+		patterns?: Routes,
+		cwd = process.cwd(),
+	): Promise<GeneratedConstruct<T>[]> {
+		const logger = console;
 
-    // Normalize patterns to array
-    const globPatterns = Array.isArray(patterns)
-      ? patterns
-      : patterns
-        ? [patterns]
-        : [];
+		// Normalize patterns to array
+		const globPatterns = Array.isArray(patterns)
+			? patterns
+			: patterns
+				? [patterns]
+				: [];
 
-    // Find all files
-    const files = fg.stream(globPatterns, {
-      cwd,
-      absolute: true,
-    });
+		// Find all files
+		const files = fg.stream(globPatterns, {
+			cwd,
+			absolute: true,
+		});
 
-    // Load constructs
-    const constructs: GeneratedConstruct<T>[] = [];
+		// Load constructs
+		const constructs: GeneratedConstruct<T>[] = [];
 
-    for await (const f of files) {
-      try {
-        const file = f.toString();
-        const module = await import(file);
+		for await (const f of files) {
+			try {
+				const file = f.toString();
+				const module = await import(file);
 
-        // Check all exports for constructs
-        for (const [key, construct] of Object.entries(module)) {
-          if (this.isConstruct(construct)) {
-            constructs.push({
-              key,
-              name: kebabCase(key),
-              construct,
-              path: {
-                absolute: file,
-                relative: relative(process.cwd(), file),
-              },
-            });
-          }
-        }
-      } catch (error) {
-        logger.warn(`Failed to load ${f}:`, (error as Error).message);
-        throw new Error(
-          'Failed to load constructs. Please check the logs for details.',
-        );
-      }
-    }
+				// Check all exports for constructs
+				for (const [key, construct] of Object.entries(module)) {
+					if (this.isConstruct(construct)) {
+						constructs.push({
+							key,
+							name: kebabCase(key),
+							construct,
+							path: {
+								absolute: file,
+								relative: relative(process.cwd(), file),
+							},
+						});
+					}
+				}
+			} catch (error) {
+				logger.warn(`Failed to load ${f}:`, (error as Error).message);
+				throw new Error(
+					'Failed to load constructs. Please check the logs for details.',
+				);
+			}
+		}
 
-    return constructs;
-  }
+		return constructs;
+	}
 }
 
 export interface GeneratedConstruct<T extends Construct> {
-  key: string;
-  name: string;
-  construct: T;
-  path: {
-    absolute: string;
-    relative: string;
-  };
+	key: string;
+	name: string;
+	construct: T;
+	path: {
+		absolute: string;
+		relative: string;
+	};
 }