@ingenyus/swarm-wasp 0.1.0 → 0.2.1

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

@@ -1,27 +1,15 @@
 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;
-    };
+    feature: z.ZodString;
+    operation: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodEnum<{
+        readonly GET: "get";
+        readonly GETALL: "getAll";
+        readonly GETFILTERED: "getFiltered";
+    }>>;
+    dataType: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    entities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    force: z.ZodOptional<z.ZodBoolean>;
+    auth: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 //# sourceMappingURL=schema.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/generators/query/schema.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAqBxB,eAAO,MAAM,MAAM;;;;;;;;;;;;iBAcjB,CAAC"}

package/dist/generators/query/schema.js

@@ -0,0 +1,115 @@
+// src/generators/query/schema.ts
+import { SchemaManager, commandRegistry as commandRegistry2 } from "@ingenyus/swarm";
+import { z as z2 } from "zod";
+
+// src/common/filesystem.ts
+import { toPascalCase, validateFeaturePath } from "@ingenyus/swarm";
+import fs from "fs";
+
+// src/types/constants.ts
+var QUERY_OPERATIONS = {
+  GET: "get",
+  GETALL: "getAll",
+  GETFILTERED: "getFiltered"
+};
+
+// src/common/filesystem.ts
+var realFileSystem = {
+  readFileSync: fs.readFileSync,
+  writeFileSync: fs.writeFileSync,
+  existsSync: fs.existsSync,
+  copyFileSync: fs.copyFileSync,
+  mkdirSync: fs.mkdirSync,
+  readdirSync: fs.readdirSync,
+  statSync: fs.statSync
+};
+
+// src/common/prisma.ts
+import {
+  getSchema
+} from "@mrleebo/prisma-ast";
+import fs2 from "fs";
+import path from "path";
+
+// 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"
+  })
+};
+
+// src/common/templates.ts
+import { toKebabCase } from "@ingenyus/swarm";
+import { Eta } from "eta";
+
+// src/generators/query/schema.ts
+var validQueries = Object.values(QUERY_OPERATIONS);
+var querySchema = z2.string().min(1, "Query type is required").transform((val) => SchemaManager.findEnumValue(QUERY_OPERATIONS, val)).pipe(
+  z2.enum(QUERY_OPERATIONS, {
+    message: `Invalid query. Must be one of: ${validQueries.join(", ")}`
+  })
+).meta({ description: "The query operation to generate" }).register(commandRegistry2, {
+  shortName: "o",
+  examples: validQueries,
+  helpText: `Available queries: ${validQueries.join(", ")}`
+});
+var schema = z2.object({
+  feature: commonSchemas.feature,
+  operation: querySchema,
+  dataType: commonSchemas.dataType,
+  name: commonSchemas.name.optional().meta({
+    ...commonSchemas.name.meta() ?? {},
+    description: `${commonSchemas.name.meta()?.description ?? ""} (optional)`
+  }).register(commandRegistry2, commandRegistry2.get(commonSchemas.name) ?? {}),
+  entities: commonSchemas.entities,
+  force: commonSchemas.force,
+  auth: commonSchemas.auth
+});
+export {
+  schema
+};