@ingenyus/swarm-wasp 0.1.0

package/dist/generators/config/templates/route.eta

@@ -0,0 +1,4 @@
+    .addRoute(feature, "<%=routeName%>", {
+      path: "<%=routePath%>",
+      auth: <%=auth%>,
+    })

package/dist/generators/config/wasp-config-generator.d.ts

@@ -0,0 +1,92 @@
+import { FileSystem, Logger } from '@ingenyus/swarm';
+import path from 'node:path';
+import { TemplateUtility } from '../../common';
+import { ConfigGenerator } from '../../generators/config';
+export declare class WaspConfigGenerator implements ConfigGenerator {
+    protected logger: Logger;
+    protected fileSystem: FileSystem;
+    protected path: path.PlatformPath;
+    protected templateUtility: TemplateUtility;
+    constructor(logger?: Logger, fileSystem?: FileSystem);
+    /**
+     * Gets the template path for feature config templates.
+     * Feature config templates are located in the feature-directory generator's templates directory.
+     * @param templateName - The name of the template file (e.g., 'feature.wasp.eta')
+     * @returns The full path to the template file
+     */
+    private getTemplatePath;
+    /**
+     * Generate a TypeScript Wasp config file in a feature directory
+     * @param featurePath - The feature directory path
+     */
+    generate(featurePath: string): void;
+    /**
+     * Updates or creates a feature configuration file with a pre-built declaration.
+     * @param featurePath - The path to the feature
+     * @param declaration - The pre-built declaration string to add or update
+     * @returns The updated feature configuration file
+     */
+    update(featurePath: string, declaration: string): string;
+    /**
+     * Determines the insertion index for a method name based on alphabetical ordering
+     * of existing groups in the configuration file.
+     * @param groups - Object containing existing method groups
+     * @param methodName - The method name to find insertion index for
+     * @returns The insertion index for the method name
+     */
+    private getInsertionIndexForMethod;
+    /**
+     * Gets the comment text for a method type.
+     * @param methodName The method name (e.g., 'addApi')
+     * @returns The comment text for the method type
+     */
+    private getMethodComment;
+    /**
+     * Finds the correct insertion point for a new configuration item.
+     * @param lines - Array of file lines
+     * @param methodName - The method name (e.g., 'addApi')
+     * @param definition - The definition string to parse for item name
+     * @returns Object with insertion index and whether to add a comment
+     */
+    private findGroupInsertionPoint;
+    /**
+     * Inserts a definition with optional comment header.
+     * @param lines - Array of file lines
+     * @param declaration - The declaration to insert
+     * @param insertIndex - The index where to insert
+     * @param methodName - The method name for comment generation
+     * @param addComment - Whether to add a comment before the declaration
+     * @returns The modified lines array
+     */
+    private insertWithSpacing;
+    /**
+     * Checks if there are any existing definitions of a specific type in the content.
+     * @param content - The file content to search
+     * @param methodName - The method name to check for (e.g., 'addJob', 'addApi')
+     * @returns true if there are existing definitions of this type, false otherwise
+     */
+    private hasExistingDefinitions;
+    /**
+     * Removes an existing definition from the content by finding the helper method call
+     * and removing the entire method call block.
+     * @param content - The file content
+     * @param definition - The new definition to find the existing one from
+     * @returns The content with the existing definition removed
+     */
+    private removeExistingDefinition;
+    /**
+     * Adds a definition to the content by finding the appropriate place to insert it.
+     * @param content - The current file content
+     * @param definition - The definition to add
+     * @returns The updated content with the new definition
+     */
+    private addDefinitionToContent;
+    /**
+     * Normalises semicolons in the config file by removing them from method chain calls
+     * while preserving them in other contexts (imports, declarations, etc.).
+     * @param content - The file content to normalise
+     * @returns The normalised content
+     */
+    private normaliseSemicolons;
+}
+//# sourceMappingURL=wasp-config-generator.d.ts.map

package/dist/generators/config/wasp-config-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wasp-config-generator.d.ts","sourceRoot":"","sources":["../../../src/generators/config/wasp-config-generator.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EAEV,MAAM,EAGP,MAAM,iBAAiB,CAAC;AACzB,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,EAAiC,eAAe,EAAE,MAAM,cAAc,CAAC;AAC9E,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE1D,qBAAa,mBAAoB,YAAW,eAAe;IAKvD,SAAS,CAAC,MAAM,EAAE,MAAM;IACxB,SAAS,CAAC,UAAU,EAAE,UAAU;IALlC,SAAS,CAAC,IAAI,oBAAQ;IACtB,SAAS,CAAC,eAAe,EAAE,eAAe,CAAC;gBAG/B,MAAM,GAAE,MAA4B,EACpC,UAAU,GAAE,UAA2B;IAKnD;;;;;OAKG;IACH,OAAO,CAAC,eAAe;IAQvB;;;OAGG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IA2BnC;;;;;OAKG;IACH,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM;IAmGxD;;;;;;OAMG;IACH,OAAO,CAAC,0BAA0B;IAYlC;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;IAQxB;;;;;;OAMG;IACH,OAAO,CAAC,uBAAuB;IA0K/B;;;;;;;;OAQG;IACH,OAAO,CAAC,iBAAiB;IAuBzB;;;;;OAKG;IACH,OAAO,CAAC,sBAAsB;IAY9B;;;;;;OAMG;IACH,OAAO,CAAC,wBAAwB;IAgFhC;;;;;OAKG;IACH,OAAO,CAAC,sBAAsB;IAoB9B;;;;;OAKG;IACH,OAAO,CAAC,mBAAmB;CAkE5B"}

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

@@ -0,0 +1,40 @@
+import { CrudFlags } from '../../generators/args.types';
+import { CONFIG_TYPES } from '../../types';
+import { OperationGeneratorBase } from '../base';
+export declare class CrudGenerator extends OperationGeneratorBase<typeof CONFIG_TYPES.CRUD> {
+    protected get entityType(): "Crud";
+    description: string;
+    schema: import("zod").ZodObject<{
+        feature: import("zod").ZodString & {
+            _metadata: import("@ingenyus/swarm").FieldMetadata;
+        };
+        name: import("zod").ZodString & {
+            _metadata: import("@ingenyus/swarm").FieldMetadata;
+        };
+        public: import("zod").ZodPipe<import("zod").ZodOptional<import("zod").ZodString>, import("zod").ZodTransform<("create" | "update" | "delete" | "get" | "getAll")[] | undefined, string | undefined>> & {
+            _metadata: import("@ingenyus/swarm").FieldMetadata;
+        };
+        override: import("zod").ZodPipe<import("zod").ZodOptional<import("zod").ZodString>, import("zod").ZodTransform<("create" | "update" | "delete" | "get" | "getAll")[] | undefined, string | undefined>> & {
+            _metadata: import("@ingenyus/swarm").FieldMetadata;
+        };
+        exclude: import("zod").ZodPipe<import("zod").ZodOptional<import("zod").ZodString>, import("zod").ZodTransform<("create" | "update" | "delete" | "get" | "getAll")[] | undefined, string | undefined>> & {
+            _metadata: import("@ingenyus/swarm").FieldMetadata;
+        };
+        force: import("zod").ZodOptional<import("zod").ZodBoolean> & {
+            _metadata: import("@ingenyus/swarm").FieldMetadata;
+        };
+    }, import("zod/v4/core").$strip>;
+    generate(flags: CrudFlags): Promise<void>;
+    private generateCrudFile;
+    private updateConfigFile;
+    private buildOperations;
+    /**
+     * Generates operation code for overridden CRUD operations and returns as a single string.
+     */
+    private getOperationsCode;
+    /**
+     * Generates a CRUD definition for the feature configuration.
+     */
+    getDefinition(crudName: string, dataType: string, operations: any): string;
+}
+//# sourceMappingURL=crud-generator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"crud-generator.d.ts","sourceRoot":"","sources":["../../../src/generators/crud/crud-generator.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AACxD,OAAO,EAAE,YAAY,EAAiB,MAAM,aAAa,CAAC;AAC1D,OAAO,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAWjD,qBAAa,aAAc,SAAQ,sBAAsB,CACvD,OAAO,YAAY,CAAC,IAAI,CACzB;IACC,SAAS,KAAK,UAAU,WAEvB;IAED,WAAW,SAAoD;IAC/D,MAAM;;;;;;;;;;;;;;;;;;;qCAAU;IAEV,QAAQ,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;YAwCjC,gBAAgB;YAyBhB,gBAAgB;IAoB9B,OAAO,CAAC,eAAe;IA+BvB;;OAEG;YACW,iBAAiB;IA0B/B;;OAEG;IACH,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,GAAG,GAAG,MAAM;CAoB3E"}

package/dist/generators/crud/index.d.ts

@@ -0,0 +1,2 @@
+export { CrudGenerator } from './crud-generator';
+//# sourceMappingURL=index.d.ts.map

package/dist/generators/crud/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/generators/crud/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/generators/crud/schema.d.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+export declare const schema: z.ZodObject<{
+    feature: z.ZodString & {
+        _metadata: import("@ingenyus/swarm").FieldMetadata;
+    };
+    name: z.ZodString & {
+        _metadata: import("@ingenyus/swarm").FieldMetadata;
+    };
+    public: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<("create" | "update" | "delete" | "get" | "getAll")[] | undefined, string | undefined>> & {
+        _metadata: import("@ingenyus/swarm").FieldMetadata;
+    };
+    override: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<("create" | "update" | "delete" | "get" | "getAll")[] | undefined, string | undefined>> & {
+        _metadata: import("@ingenyus/swarm").FieldMetadata;
+    };
+    exclude: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<("create" | "update" | "delete" | "get" | "getAll")[] | undefined, string | undefined>> & {
+        _metadata: import("@ingenyus/swarm").FieldMetadata;
+    };
+    force: z.ZodOptional<z.ZodBoolean> & {
+        _metadata: import("@ingenyus/swarm").FieldMetadata;
+    };
+}, z.core.$strip>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/generators/crud/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/generators/crud/schema.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAaxB,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;iBAyBjB,CAAC"}

package/dist/generators/crud/templates/config/crud.eta

@@ -0,0 +1,4 @@
+    .addCrud(feature, "<%=crudName%>", {
+      entity: "<%=dataType%>",
+      <%=operations%>,
+    })

package/dist/generators/crud/templates/crud.eta

@@ -0,0 +1,2 @@
+<%=imports%>
+<%=operations-%>

package/dist/generators/feature-directory/feature-directory-generator.d.ts

@@ -0,0 +1,18 @@
+import { ExtendedSchema, FileSystem, Logger } from '@ingenyus/swarm';
+import { WaspGeneratorBase } from '../base/wasp-generator.base';
+import { SchemaArgs } from './schema';
+export declare class FeatureDirectoryGenerator extends WaspGeneratorBase<SchemaArgs> {
+    logger: Logger;
+    fileSystem: FileSystem;
+    name: string;
+    description: string;
+    schema: ExtendedSchema;
+    constructor(logger?: Logger, fileSystem?: FileSystem);
+    protected getDefaultTemplatePath(templateName: string): string;
+    /**
+     * Generate feature directory structure (main entry point)
+     * @param featurePath - The path to the feature
+     */
+    generate(flags: SchemaArgs): Promise<void>;
+}
+//# sourceMappingURL=feature-directory-generator.d.ts.map

package/dist/generators/feature-directory/feature-directory-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-directory-generator.d.ts","sourceRoot":"","sources":["../../../src/generators/feature-directory/feature-directory-generator.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,UAAU,EAEV,MAAM,EAGP,MAAM,iBAAiB,CAAC;AAOzB,OAAO,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAU,UAAU,EAAE,MAAM,UAAU,CAAC;AAE9C,qBAAa,yBAA0B,SAAQ,iBAAiB,CAAC,UAAU,CAAC;IAMjE,MAAM,EAAE,MAAM;IACd,UAAU,EAAE,UAAU;IAN/B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,cAAc,CAAC;gBAGd,MAAM,GAAE,MAA4B,EACpC,UAAU,GAAE,UAA2B;IAQhD,SAAS,CAAC,sBAAsB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM;IAQ9D;;;OAGG;IACG,QAAQ,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;CA0BjD"}

package/dist/generators/feature-directory/index.d.ts

@@ -0,0 +1,2 @@
+export { FeatureDirectoryGenerator } from './feature-directory-generator';
+//# sourceMappingURL=index.d.ts.map

package/dist/generators/feature-directory/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/generators/feature-directory/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAC"}

package/dist/generators/feature-directory/schema.d.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+export declare const schema: z.ZodObject<{
+    path: z.ZodString & {
+        _metadata: import("@ingenyus/swarm").FieldMetadata;
+    };
+}, z.core.$strip>;
+export type SchemaArgs = z.infer<typeof schema>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/generators/feature-directory/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/generators/feature-directory/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,MAAM;;;;iBAEjB,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,CAAC"}

package/dist/generators/feature-directory/templates/feature.wasp.eta

@@ -0,0 +1,22 @@
+import { App } from "@ingenyus/swarm-wasp";
+
+/**
+ * Fluent Wasp feature configuration
+ *
+ * Example usage:
+ * ```ts
+ * app
+ *   .addApi(feature, "getItems", {
+ *     method: "GET", route: "/api/feature/items", entities: ["Item"], auth: true
+ *   })
+ *   .addApiNamespace(feature, "apiNamespace", {
+ *     path: "/api/feature"
+ *   })
+ *   .addRoute(feature, "featureRoute", {
+ *     path: "/feature", componentName: "Feature", auth: false
+ *   });
+ * ```
+ */
+export default function configureFeature(app: App, feature: string): void {
+  app
+}

package/dist/generators/index.d.ts

@@ -0,0 +1,10 @@
+export { ActionGenerator } from './action';
+export { ApiGenerator } from './api';
+export { ApiNamespaceGenerator } from './api-namespace';
+export { WaspConfigGenerator } from './config';
+export { CrudGenerator } from './crud';
+export { FeatureDirectoryGenerator } from './feature-directory';
+export { JobGenerator } from './job';
+export { QueryGenerator } from './query';
+export { RouteGenerator } from './route';
+//# sourceMappingURL=index.d.ts.map

package/dist/generators/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/generators/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAC3C,OAAO,EAAE,YAAY,EAAE,MAAM,OAAO,CAAC;AACrC,OAAO,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AACvC,OAAO,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AAChE,OAAO,EAAE,YAAY,EAAE,MAAM,OAAO,CAAC;AACrC,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC"}

package/dist/generators/job/index.d.ts

@@ -0,0 +1,2 @@
+export { JobGenerator } from './job-generator';
+//# sourceMappingURL=index.d.ts.map

package/dist/generators/job/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/generators/job/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC"}

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

@@ -0,0 +1,35 @@
+import { JobFlags } from '../../generators/args.types';
+import { CONFIG_TYPES } from '../../types';
+import { EntityGeneratorBase } from '../base';
+export declare class JobGenerator extends EntityGeneratorBase<typeof CONFIG_TYPES.JOB> {
+    protected get entityType(): "Job";
+    description: string;
+    schema: import("zod").ZodObject<{
+        feature: import("zod").ZodString & {
+            _metadata: import("@ingenyus/swarm").FieldMetadata;
+        };
+        name: import("zod").ZodString & {
+            _metadata: import("@ingenyus/swarm").FieldMetadata;
+        };
+        entities: import("zod").ZodOptional<import("zod").ZodString> & {
+            _metadata: import("@ingenyus/swarm").FieldMetadata;
+        };
+        cron: import("zod").ZodOptional<import("zod").ZodString> & {
+            _metadata: import("@ingenyus/swarm").FieldMetadata;
+        };
+        args: import("zod").ZodOptional<import("zod").ZodString> & {
+            _metadata: import("@ingenyus/swarm").FieldMetadata;
+        };
+        force: import("zod").ZodOptional<import("zod").ZodBoolean> & {
+            _metadata: import("@ingenyus/swarm").FieldMetadata;
+        };
+    }, import("zod/v4/core").$strip>;
+    generate(flags: JobFlags): Promise<void>;
+    private generateJobFile;
+    private updateConfigFile;
+    /**
+     * Generates a job definition for the feature configuration.
+     */
+    getDefinition(jobName: string, entities: string[], cron: string, args: string): string;
+}
+//# sourceMappingURL=job-generator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"job-generator.d.ts","sourceRoot":"","sources":["../../../src/generators/job/job-generator.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAG9C,qBAAa,YAAa,SAAQ,mBAAmB,CAAC,OAAO,YAAY,CAAC,GAAG,CAAC;IAC5E,SAAS,KAAK,UAAU,UAEvB;IAED,WAAW,SAAgD;IAC3D,MAAM;;;;;;;;;;;;;;;;;;;qCAAU;IAEV,QAAQ,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;YAgBhC,eAAe;IAgC7B,OAAO,CAAC,gBAAgB;IA8BxB;;OAEG;IACH,aAAa,CACX,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAAE,EAClB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACX,MAAM;CAUV"}

package/dist/generators/job/schema.d.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+export declare const schema: z.ZodObject<{
+    feature: z.ZodString & {
+        _metadata: import("@ingenyus/swarm").FieldMetadata;
+    };
+    name: z.ZodString & {
+        _metadata: import("@ingenyus/swarm").FieldMetadata;
+    };
+    entities: z.ZodOptional<z.ZodString> & {
+        _metadata: import("@ingenyus/swarm").FieldMetadata;
+    };
+    cron: z.ZodOptional<z.ZodString> & {
+        _metadata: import("@ingenyus/swarm").FieldMetadata;
+    };
+    args: z.ZodOptional<z.ZodString> & {
+        _metadata: import("@ingenyus/swarm").FieldMetadata;
+    };
+    force: z.ZodOptional<z.ZodBoolean> & {
+        _metadata: import("@ingenyus/swarm").FieldMetadata;
+    };
+}, z.core.$strip>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/generators/job/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/generators/job/schema.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA4HxB,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;iBAOjB,CAAC"}

package/dist/generators/job/templates/config/job.eta

@@ -0,0 +1,9 @@
+    .addJob(feature, "<%=jobName%>", {
+      cron: "<%=cron%>",
+<%- if (args !== '{}') { %>
+      args: <%=args%>,
+<%- } %>
+<%- if (entities.length > 0) { %>
+      entities: [<%=entities%>],
+<%- } %>
+    })

package/dist/generators/job/templates/job.eta

@@ -0,0 +1,5 @@
+<%=imports%>
+export const <%=jobName%>: <%=jobType%><never, void> = async (_args, _context) => {
+  // TODO: Implement job logic
+  console.log("Job executed");
+}

package/dist/generators/operation/templates/config/operation.eta

@@ -0,0 +1,6 @@
+    .add<%=operationType%>(feature, "<%=operationName%>", {
+<%- if (entities.length > 0) { %>
+      entities: [<%=entities%>],
+<%- } %>
+      auth: <%=auth%>,
+    })

package/dist/generators/operation/templates/create.eta

@@ -0,0 +1,17 @@
+<%=imports%>
+
+export const <%=operationName%><%=typeAnnotation%> = async (data, context) => {
+<%=authCheck%>  try {
+    const created<%=modelName%> = await context.entities.<%=modelName%>.create({
+      data: {
+        ...data<%=jsonTypeHandling%>,
+      }
+    });
+
+    return created<%=modelName%>;
+  } catch (error) {
+    console.error("Failed to create <%=modelName%>:", error);
+
+    throw new HttpError(500, "Failed to create <%=modelName%>");
+  }
+}; <%=satisfiesType%>

package/dist/generators/operation/templates/delete.eta

@@ -0,0 +1,21 @@
+<%=imports%>
+
+export const <%=operationName%><%=typeAnnotation%> = async ({ <%=idFieldParams%> }, context) => {
+<%=authCheck%>  try {
+    const <%=modelNameLower%> = await context.entities.<%=modelName%>.findUnique({
+      where: { <%=whereClause%> },
+    });
+
+    if (!<%=modelNameLower%>) {
+      throw new HttpError(404, `<%=modelName%> ${<%=idField%>} not found`);
+    }
+
+    await context.entities.<%=modelName%>.delete({
+      where: { <%=whereClause%> },
+    });
+  } catch (error) {
+    console.error(`Failed to delete <%=modelNameLower%> ${<%=idField%>}:`, error);
+
+    throw new HttpError(500, `Failed to delete <%=modelNameLower%> ${<%=idField%>}`);
+  }
+}; <%=satisfiesType%>

package/dist/generators/operation/templates/get.eta

@@ -0,0 +1,19 @@
+<%=imports%>
+
+export const <%=operationName%><%=typeAnnotation%> = (async ({ <%=idFieldParams%> }, context) => {
+<%=authCheck%>  try {
+    const <%=modelNameLower%> = await context.entities.<%=modelName%>.findUnique({
+      where: { <%=whereClause%> },
+    });
+
+    if (!<%=modelNameLower%>) {
+      throw new HttpError(404, `<%=modelNameLower%> ${<%=idField%>} not found`);
+    }
+
+    return <%=modelNameLower%>;
+  } catch (error) {
+    console.error(`Failed to get <%=modelNameLower%> ${<%=idField%>}:`, error);
+
+    throw new HttpError(500, `Failed to get <%=modelNameLower%> ${<%=idField%>}`);
+  }
+}) <%=satisfiesType%>;

package/dist/generators/operation/templates/getAll.eta

@@ -0,0 +1,13 @@
+<%=imports%>
+
+export const <%=operationName%><%=typeAnnotation%> = (async (_args, context) => {
+<%=authCheck%>  try {
+    const <%=pluralModelNameLower%> = await context.entities.<%=modelName%>.findMany();
+
+    return <%=pluralModelNameLower%>;
+  } catch (error) {
+    console.error("Failed to get all <%=pluralModelNameLower%>:", error);
+
+    throw new HttpError(500, "Failed to get all <%=pluralModelNameLower%>");
+  }
+}) <%=satisfiesType%>;

package/dist/generators/operation/templates/getFiltered.eta

@@ -0,0 +1,17 @@
+<%=imports%>
+
+export const <%=operationName%><%=typeAnnotation%> = (async (args, context) => {
+<%=authCheck%>  try {
+    const <%=pluralModelNameLower%> = await context.entities.<%=modelName%>.findMany({
+      where: {
+        ...args,
+      },
+    });
+
+    return <%=pluralModelNameLower%>;
+  } catch (error) {
+    console.error("Failed to get filtered <%=pluralModelNameLower%>:", error);
+
+    throw new HttpError(500, "Failed to get filtered <%=pluralModelNameLower%>");
+  }
+}) <%=satisfiesType%>;

package/dist/generators/operation/templates/update.eta

@@ -0,0 +1,26 @@
+<%=imports%>
+
+export const <%=operationName%><%=typeAnnotation%> = async ({ <%=idField%>, ...data }, context) => {
+<%=authCheck%>  try {
+    const <%=modelNameLower%> = await context.entities.<%=modelName%>.findUnique({
+      where: { <%=idField%> },
+    });
+
+    if (!<%=modelNameLower%>) {
+      throw new HttpError(404, `<%=modelName%> ${<%=idField%>} not found`);
+    }
+
+    const updated<%=modelName%> = await context.entities.<%=modelName%>.update({
+      where: { <%=idField%> },
+      data: {
+        ...data<%=jsonTypeHandling%>,
+      },
+    });
+
+    return updated<%=modelName%>;
+  } catch (error) {
+    console.error(`Failed to update <%=modelNameLower%> ${<%=idField%>}:`, error);
+
+    throw new HttpError(500, `Failed to update <%=modelNameLower%> ${<%=idField%>}`);
+  }
+}; <%=satisfiesType%>

package/dist/generators/query/index.d.ts

@@ -0,0 +1,2 @@
+export { QueryGenerator } from './query-generator';
+//# sourceMappingURL=index.d.ts.map

package/dist/generators/query/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/generators/query/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC"}

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

@@ -0,0 +1,36 @@
+import { QueryFlags } from '../../generators/args.types';
+import { CONFIG_TYPES } from '../../types';
+import { OperationGeneratorBase } from '../base';
+export declare class QueryGenerator extends OperationGeneratorBase<typeof CONFIG_TYPES.QUERY> {
+    protected get entityType(): "Query";
+    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<"get" | "getAll" | "getFiltered", 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;
+        };
+    }, import("zod/v4/core").$strip>;
+    generate(flags: Omit<QueryFlags, 'name'> & {
+        name?: string;
+    }): Promise<void>;
+}
+//# sourceMappingURL=query-generator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"query-generator.d.ts","sourceRoot":"","sources":["../../../src/generators/query/query-generator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAGjD,qBAAa,cAAe,SAAQ,sBAAsB,CACxD,OAAO,YAAY,CAAC,KAAK,CAC1B;IACC,SAAS,KAAK,UAAU,YAEvB;IAED,WAAW,SAA4D;IACvE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;qCAAU;IAEV,QAAQ,CACZ,KAAK,EAAE,IAAI,CAAC,UAAU,EAAE,MAAM,CAAC,GAAG;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,GAClD,OAAO,CAAC,IAAI,CAAC;CAiEjB"}

package/dist/generators/query/schema.d.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+export declare const schema: z.ZodObject<{
+    feature: z.ZodString & {
+        _metadata: import("@ingenyus/swarm").FieldMetadata;
+    };
+    operation: z.ZodPipe<z.ZodString, z.ZodTransform<"get" | "getAll" | "getFiltered", string>> & {
+        _metadata: import("@ingenyus/swarm").FieldMetadata;
+    };
+    dataType: z.ZodString & {
+        _metadata: import("@ingenyus/swarm").FieldMetadata;
+    };
+    name: z.ZodOptional<z.ZodString & {
+        _metadata: import("@ingenyus/swarm").FieldMetadata;
+    }> & {
+        _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;
+    };
+}, z.core.$strip>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/generators/query/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/generators/query/schema.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAmCxB,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;iBAQjB,CAAC"}

package/dist/generators/route/index.d.ts

@@ -0,0 +1,2 @@
+export { RouteGenerator } from './route-generator';
+//# sourceMappingURL=index.d.ts.map

package/dist/generators/route/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/generators/route/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC"}

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

@@ -0,0 +1,32 @@
+import { RouteFlags } from '../../generators/args.types';
+import { CONFIG_TYPES } from '../../types';
+import { EntityGeneratorBase } from '../base';
+export declare class RouteGenerator extends EntityGeneratorBase<typeof CONFIG_TYPES.ROUTE> {
+    protected get entityType(): "Route";
+    description: string;
+    schema: import("zod").ZodObject<{
+        feature: import("zod").ZodString & {
+            _metadata: import("@ingenyus/swarm").FieldMetadata;
+        };
+        name: import("zod").ZodString & {
+            _metadata: import("@ingenyus/swarm").FieldMetadata;
+        };
+        path: import("zod").ZodString & {
+            _metadata: import("@ingenyus/swarm").FieldMetadata;
+        };
+        auth: import("zod").ZodOptional<import("zod").ZodBoolean> & {
+            _metadata: import("@ingenyus/swarm").FieldMetadata;
+        };
+        force: import("zod").ZodOptional<import("zod").ZodBoolean> & {
+            _metadata: import("@ingenyus/swarm").FieldMetadata;
+        };
+    }, import("zod/v4/core").$strip>;
+    generate(flags: RouteFlags): Promise<void>;
+    private generatePageFile;
+    private updateConfigFile;
+    /**
+     * Generates a route definition for the feature configuration.
+     */
+    getDefinition(routeName: string, routePath: string, featurePath: string, auth?: boolean): string;
+}
+//# sourceMappingURL=route-generator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"route-generator.d.ts","sourceRoot":"","sources":["../../../src/generators/route/route-generator.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAG9C,qBAAa,cAAe,SAAQ,mBAAmB,CACrD,OAAO,YAAY,CAAC,KAAK,CAC1B;IACC,SAAS,KAAK,UAAU,YAEvB;IAED,WAAW,SAAmD;IAC9D,MAAM;;;;;;;;;;;;;;;;qCAAU;IAEV,QAAQ,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;YAgBlC,gBAAgB;IAoB9B,OAAO,CAAC,gBAAgB;IAwBxB;;OAEG;IACH,aAAa,CACX,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,EACnB,IAAI,UAAQ,GACX,MAAM;CAUV"}