@ingenyus/swarm-wasp 0.1.0 → 0.2.0

package/dist/common/schemas.d.ts

@@ -4,47 +4,13 @@ import { z } from 'zod';
  * These provide consistent validation rules for common generator arguments
  */
 export declare const commonSchemas: {
-    feature: z.ZodString & {
-        _metadata: import("@ingenyus/swarm").FieldMetadata;
-    };
-    name: z.ZodString & {
-        _metadata: import("@ingenyus/swarm").FieldMetadata;
-    };
-    path: z.ZodString & {
-        _metadata: import("@ingenyus/swarm").FieldMetadata;
-    };
-    entities: z.ZodOptional<z.ZodString> & {
-        _metadata: import("@ingenyus/swarm").FieldMetadata;
-    };
-    force: z.ZodOptional<z.ZodBoolean> & {
-        _metadata: import("@ingenyus/swarm").FieldMetadata;
-    };
-    auth: z.ZodOptional<z.ZodBoolean> & {
-        _metadata: import("@ingenyus/swarm").FieldMetadata;
-    };
+    feature: z.ZodString;
+    name: z.ZodString;
+    target: z.ZodString;
+    path: z.ZodString;
+    dataType: z.ZodString;
+    entities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    force: z.ZodOptional<z.ZodBoolean>;
+    auth: z.ZodOptional<z.ZodBoolean>;
 };
-/**
- * Creates a case-insensitive validation function for typed arrays
- * @param validValues - Array of valid type values
- * @returns A function that validates a comma-separated string as an array of typed values
- */
-export declare const getTypedArrayValidator: <T extends string>(validValues: readonly T[]) => (input: string | undefined) => boolean;
-/**
- * Creates a case-insensitive transformation function for typed arrays
- * @param validValues - Array of valid type values
- * @returns A function that transforms a comma-separated string to an array of typed values
- */
-export declare const getTypedArrayTransformer: <T extends string>(validValues: readonly T[]) => (input: string | undefined) => T[] | undefined;
-/**
- * Creates a case-insensitive validation function for single typed values
- * @param validValues - Array of valid type values
- * @returns A function that validates a string as an enum value
- */
-export declare const getTypedValueValidator: <T extends string>(validValues: readonly T[]) => (value: string) => boolean;
-/**
- * Creates a case-insensitive transformation function for single typed values
- * @param validValues - Array of valid type values
- * @returns A function that transforms a string to a typed value
- */
-export declare const getTypedValueTransformer: <T extends string>(validValues: readonly T[]) => (value: string) => T;
 //# sourceMappingURL=schemas.d.ts.map

package/dist/common/schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/common/schemas.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;GAGG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;CA6Cc,CAAC;AAEzC;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,GAAI,CAAC,SAAS,MAAM,EACrD,aAAa,SAAS,CAAC,EAAE,MAEjB,OAAO,MAAM,GAAG,SAAS,KAAG,OAmBrC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,GAAI,CAAC,SAAS,MAAM,EACvD,aAAa,SAAS,CAAC,EAAE,MAEjB,OAAO,MAAM,GAAG,SAAS,KAAG,CAAC,EAAE,GAAG,SAiB3C,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,GAAI,CAAC,SAAS,MAAM,EACrD,aAAa,SAAS,CAAC,EAAE,MAEjB,OAAO,MAAM,KAAG,OAMzB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,GAAI,CAAC,SAAS,MAAM,EACvD,aAAa,SAAS,CAAC,EAAE,MAEjB,OAAO,MAAM,KAAG,CAQzB,CAAC"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/common/schemas.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;GAGG;AACH,eAAO,MAAM,aAAa;;;;;;;;;CAqFc,CAAC"}

package/dist/common/schemas.js

@@ -0,0 +1,54 @@
+// src/common/schemas.ts
+import { commandRegistry } from "@ingenyus/swarm";
+import { z } from "zod";
+var commonSchemas = {
+  feature: z.string().min(1, "Feature is required").meta({
+    description: "The feature directory this component will be generated in"
+  }).register(commandRegistry, {
+    shortName: "f",
+    examples: ["root", "auth", "dashboard/users"],
+    helpText: "Can be nested as a logical or relative path, e.g. 'dashboard/users' or 'features/dashboard/features/users'"
+  }),
+  name: z.string().min(1, "Name is required").meta({ description: "The name of the generated component" }).register(commandRegistry, {
+    shortName: "n",
+    examples: ["users", "task"],
+    helpText: "Will be used for generated files and configuration entries"
+  }),
+  target: z.string().min(1, "Target directory is required").meta({ description: "The target path of the generated directory" }).register(commandRegistry, {
+    shortName: "t",
+    examples: ["dashboard/users", "features/dashboard/features/users"],
+    helpText: "A logical or relative path, e.g. 'dashboard/users' or 'features/dashboard/features/users'"
+  }),
+  path: z.string().min(1, "Path is required").meta({ description: "The path that this component will be accessible at" }).register(commandRegistry, {
+    shortName: "p",
+    examples: ["/api/users/:id", "/api/products"],
+    helpText: "Supports Express-style placeholders, e.g. '/api/users/:id'"
+  }),
+  dataType: z.string().min(1, "Data type is required").meta({ description: "The data type/model name for this operation" }).register(commandRegistry, {
+    shortName: "d",
+    examples: ["User", "Product", "Task"],
+    helpText: "The Wasp entity or model name this operation will interact with"
+  }),
+  entities: z.array(z.string()).optional().meta({
+    description: "The Wasp entities that will be available to this component (optional)"
+  }).register(commandRegistry, {
+    shortName: "e",
+    examples: ["User", "User Task"],
+    helpText: "An array of Wasp entity names"
+  }),
+  force: z.boolean().optional().meta({
+    description: "Force overwrite of existing files and configuration entries (optional)"
+  }).register(commandRegistry, {
+    shortName: "F",
+    helpText: "CAUTION: Will overwrite existing files and configuration entries with current parameters"
+  }),
+  auth: z.boolean().optional().meta({
+    description: "Require authentication for this component (optional)"
+  }).register(commandRegistry, {
+    shortName: "a",
+    helpText: "Will generate authentication checks"
+  })
+};
+export {
+  commonSchemas
+};

package/dist/common/templates.js

@@ -0,0 +1,52 @@
+// src/common/templates.ts
+import { toKebabCase } from "@ingenyus/swarm";
+import { Eta } from "eta";
+import path from "path";
+var TemplateUtility = class {
+  constructor(fileSystem) {
+    this.fileSystem = fileSystem;
+  }
+  processTemplate(templatePath, replacements) {
+    const declarations = Object.keys(replacements).map((key) => `${key}=it.${key}`).join(", ");
+    const functionHeader = declarations ? `const ${declarations};` : void 0;
+    const templateDir = path.dirname(templatePath);
+    const eta = new Eta({
+      autoTrim: false,
+      autoEscape: false,
+      views: templateDir,
+      functionHeader
+    });
+    const templateName = path.basename(templatePath).replace(/\.eta$/, "");
+    if (this.fileSystem.existsSync(templatePath)) {
+      return eta.render(templateName, replacements);
+    } else {
+      const template = this.fileSystem.readFileSync(templatePath, "utf8");
+      return eta.renderString(template, replacements);
+    }
+  }
+  /**
+   * Helper method to resolve template paths for concrete generators
+   * @param relativePath - The relative path to the template file
+   * @param generatorName - The name of the generator (e.g., 'api', 'job')
+   * @param currentFileUrl - The import.meta.url from the concrete generator class
+   * @returns The full path to the template file
+   */
+  resolveTemplatePath(relativePath, generatorName, currentFileUrl) {
+    const generatorDirName = toKebabCase(generatorName);
+    const currentFilePath = new URL(currentFileUrl).pathname;
+    const currentFileDir = path.dirname(currentFilePath);
+    const currentFileName = path.basename(currentFilePath);
+    const isInstalledPackage = currentFileDir.includes("node_modules") && currentFileDir.endsWith("/dist") && currentFileName === "index.js";
+    const startDir = isInstalledPackage ? currentFileDir : path.dirname(path.dirname(currentFileDir));
+    return path.join(
+      startDir,
+      "generators",
+      generatorDirName,
+      "templates",
+      relativePath
+    );
+  }
+};
+export {
+  TemplateUtility
+};

package/dist/generators/action/action-generator.d.ts

@@ -1,36 +1,23 @@
-import { ActionFlags } from '../../generators/args.types';
+import { Out } from '@ingenyus/swarm';
 import { CONFIG_TYPES } from '../../types';
 import { OperationGeneratorBase } from '../base';
-export declare class ActionGenerator extends OperationGeneratorBase<typeof CONFIG_TYPES.ACTION> {
-    protected get entityType(): "Action";
+import { schema } from './schema';
+export declare class ActionGenerator extends OperationGeneratorBase<typeof schema, typeof CONFIG_TYPES.ACTION> {
+    protected get componentType(): "Action";
     description: string;
     schema: import("zod").ZodObject<{
-        feature: import("zod").ZodString & {
-            _metadata: import("@ingenyus/swarm").FieldMetadata;
-        };
-        operation: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<"create" | "update" | "delete", string>> & {
-            _metadata: import("@ingenyus/swarm").FieldMetadata;
-        };
-        dataType: import("zod").ZodString & {
-            _metadata: import("@ingenyus/swarm").FieldMetadata;
-        };
-        name: import("zod").ZodOptional<import("zod").ZodString & {
-            _metadata: import("@ingenyus/swarm").FieldMetadata;
-        }> & {
-            _metadata: import("@ingenyus/swarm").FieldMetadata;
-        };
-        entities: import("zod").ZodOptional<import("zod").ZodString> & {
-            _metadata: import("@ingenyus/swarm").FieldMetadata;
-        };
-        force: import("zod").ZodOptional<import("zod").ZodBoolean> & {
-            _metadata: import("@ingenyus/swarm").FieldMetadata;
-        };
-        auth: import("zod").ZodOptional<import("zod").ZodBoolean> & {
-            _metadata: import("@ingenyus/swarm").FieldMetadata;
-        };
+        feature: import("zod").ZodString;
+        operation: import("zod").ZodPipe<import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<string, string>>, import("zod").ZodEnum<{
+            readonly CREATE: "create";
+            readonly UPDATE: "update";
+            readonly DELETE: "delete";
+        }>>;
+        dataType: import("zod").ZodString;
+        name: import("zod").ZodOptional<import("zod").ZodString>;
+        entities: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        force: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        auth: import("zod").ZodOptional<import("zod").ZodBoolean>;
     }, import("zod/v4/core").$strip>;
-    generate(flags: Omit<ActionFlags, 'name'> & {
-        name?: string;
-    }): Promise<void>;
+    generate(args: Out<typeof schema>): Promise<void>;
 }
 //# sourceMappingURL=action-generator.d.ts.map

package/dist/generators/action/action-generator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"action-generator.d.ts","sourceRoot":"","sources":["../../../src/generators/action/action-generator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAGjD,qBAAa,eAAgB,SAAQ,sBAAsB,CACzD,OAAO,YAAY,CAAC,MAAM,CAC3B;IACC,SAAS,KAAK,UAAU,aAEvB;IAED,WAAW,SAAwD;IACnE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;qCAAU;IAEV,QAAQ,CACZ,KAAK,EAAE,IAAI,CAAC,WAAW,EAAE,MAAM,CAAC,GAAG;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,GACnD,OAAO,CAAC,IAAI,CAAC;CAiEjB"}
+{"version":3,"file":"action-generator.d.ts","sourceRoot":"","sources":["../../../src/generators/action/action-generator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,iBAAiB,CAAC;AACtC,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AACjD,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC,qBAAa,eAAgB,SAAQ,sBAAsB,CACzD,OAAO,MAAM,EACb,OAAO,YAAY,CAAC,MAAM,CAC3B;IACC,SAAS,KAAK,aAAa,aAE1B;IAED,WAAW,SAA6B;IACxC,MAAM;;;;;;;;;;;;qCAAU;IAEV,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAC,OAAO,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;CA0DxD"}