@ingenyus/swarm-wasp 0.1.0 → 0.2.1

package/dist/common/filesystem.js

@@ -0,0 +1,123 @@
+// src/common/filesystem.ts
+import { toPascalCase, validateFeaturePath } from "@ingenyus/swarm";
+import fs from "fs";
+import path from "path";
+
+// src/types/constants.ts
+var TYPE_DIRECTORIES = {
+  component: "client/components",
+  hook: "client/hooks",
+  layout: "client/layouts",
+  page: "client/pages",
+  util: "client/utils",
+  action: "server/actions",
+  query: "server/queries",
+  middleware: "server/middleware",
+  job: "server/jobs",
+  api: "server/apis",
+  crud: "server/cruds",
+  type: "types"
+};
+
+// 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
+};
+function findWaspRoot(fileSystem, startDir = process.cwd()) {
+  const startDirPath = path.resolve(startDir);
+  let currentDirPath = startDirPath;
+  const root = path.parse(currentDirPath).root;
+  while (currentDirPath !== root) {
+    const waspRootPath = path.join(currentDirPath, ".wasproot");
+    if (fileSystem.existsSync(waspRootPath)) {
+      return currentDirPath;
+    }
+    currentDirPath = path.dirname(currentDirPath);
+  }
+  throw new Error(
+    `Couldn't find Wasp application root from ${startDirPath}. Make sure you are running this command from within a Wasp project directory.`
+  );
+}
+function copyDirectory(fileSystem, src, dest) {
+  if (!fileSystem.existsSync(dest)) {
+    fileSystem.mkdirSync(dest, { recursive: true });
+  }
+  const entries = fileSystem.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirectory(fileSystem, srcPath, destPath);
+    } else {
+      fileSystem.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+function ensureDirectoryExists(fileSystem, dir) {
+  if (!fileSystem.existsSync(dir)) {
+    fileSystem.mkdirSync(dir, { recursive: true });
+  }
+}
+function featureExists(fileSystem, featurePath) {
+  return fileSystem.existsSync(getFeatureDir(fileSystem, featurePath));
+}
+function getConfigDir(fileSystem) {
+  const waspRoot = findWaspRoot(fileSystem);
+  return path.join(waspRoot, "config");
+}
+function normaliseFeaturePath(featurePath) {
+  const segments = validateFeaturePath(featurePath);
+  const normalisedSegments = [];
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i];
+    const previousSegment = normalisedSegments[normalisedSegments.length - 1];
+    if (previousSegment !== "features" && segment !== "features") {
+      normalisedSegments.push("features");
+    }
+    normalisedSegments.push(segment);
+  }
+  return normalisedSegments.join("/");
+}
+function getFeatureDir(fileSystem, featureName) {
+  const waspRoot = findWaspRoot(fileSystem);
+  const normalisedPath = normaliseFeaturePath(featureName);
+  return path.join(waspRoot, "src", normalisedPath);
+}
+function getFeatureImportPath(featurePath) {
+  const segments = validateFeaturePath(featurePath);
+  return segments.join("/");
+}
+function getFeatureTargetDir(fileSystem, featurePath, type) {
+  validateFeaturePath(featurePath);
+  const normalisedPath = normaliseFeaturePath(featurePath);
+  const featureDir = getFeatureDir(fileSystem, normalisedPath);
+  const typeKey = type.toLowerCase();
+  const typeDirectory = TYPE_DIRECTORIES[typeKey];
+  const targetDirectory = path.join(featureDir, typeDirectory);
+  const importDirectory = `@src/${normalisedPath}/${typeDirectory}`;
+  return { targetDirectory, importDirectory };
+}
+function getRouteNameFromPath(routePath) {
+  const lastSegment = routePath.split("/").filter(Boolean).pop() || "index";
+  const cleanSegment = lastSegment.replace(/[:*]/g, "");
+  return `${toPascalCase(cleanSegment)}Page`;
+}
+export {
+  copyDirectory,
+  ensureDirectoryExists,
+  featureExists,
+  findWaspRoot,
+  getConfigDir,
+  getFeatureDir,
+  getFeatureImportPath,
+  getFeatureTargetDir,
+  getRouteNameFromPath,
+  normaliseFeaturePath,
+  realFileSystem
+};

package/dist/common/index.d.ts

@@ -1,5 +1,4 @@
 export * from './filesystem';
-export * from './plugin';
 export * from './prisma';
 export * from './schemas';
 export * from './templates';

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/common/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/common/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC"}

package/dist/common/index.js

@@ -0,0 +1,366 @@
+// src/common/filesystem.ts
+import { toPascalCase, validateFeaturePath } from "@ingenyus/swarm";
+import fs from "fs";
+import path from "path";
+
+// src/types/constants.ts
+var TYPE_DIRECTORIES = {
+  component: "client/components",
+  hook: "client/hooks",
+  layout: "client/layouts",
+  page: "client/pages",
+  util: "client/utils",
+  action: "server/actions",
+  query: "server/queries",
+  middleware: "server/middleware",
+  job: "server/jobs",
+  api: "server/apis",
+  crud: "server/cruds",
+  type: "types"
+};
+
+// 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
+};
+function findWaspRoot(fileSystem, startDir = process.cwd()) {
+  const startDirPath = path.resolve(startDir);
+  let currentDirPath = startDirPath;
+  const root = path.parse(currentDirPath).root;
+  while (currentDirPath !== root) {
+    const waspRootPath = path.join(currentDirPath, ".wasproot");
+    if (fileSystem.existsSync(waspRootPath)) {
+      return currentDirPath;
+    }
+    currentDirPath = path.dirname(currentDirPath);
+  }
+  throw new Error(
+    `Couldn't find Wasp application root from ${startDirPath}. Make sure you are running this command from within a Wasp project directory.`
+  );
+}
+function copyDirectory(fileSystem, src, dest) {
+  if (!fileSystem.existsSync(dest)) {
+    fileSystem.mkdirSync(dest, { recursive: true });
+  }
+  const entries = fileSystem.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirectory(fileSystem, srcPath, destPath);
+    } else {
+      fileSystem.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+function ensureDirectoryExists(fileSystem, dir) {
+  if (!fileSystem.existsSync(dir)) {
+    fileSystem.mkdirSync(dir, { recursive: true });
+  }
+}
+function featureExists(fileSystem, featurePath) {
+  return fileSystem.existsSync(getFeatureDir(fileSystem, featurePath));
+}
+function getConfigDir(fileSystem) {
+  const waspRoot = findWaspRoot(fileSystem);
+  return path.join(waspRoot, "config");
+}
+function normaliseFeaturePath(featurePath) {
+  const segments = validateFeaturePath(featurePath);
+  const normalisedSegments = [];
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i];
+    const previousSegment = normalisedSegments[normalisedSegments.length - 1];
+    if (previousSegment !== "features" && segment !== "features") {
+      normalisedSegments.push("features");
+    }
+    normalisedSegments.push(segment);
+  }
+  return normalisedSegments.join("/");
+}
+function getFeatureDir(fileSystem, featureName) {
+  const waspRoot = findWaspRoot(fileSystem);
+  const normalisedPath = normaliseFeaturePath(featureName);
+  return path.join(waspRoot, "src", normalisedPath);
+}
+function getFeatureImportPath(featurePath) {
+  const segments = validateFeaturePath(featurePath);
+  return segments.join("/");
+}
+function getFeatureTargetDir(fileSystem, featurePath, type) {
+  validateFeaturePath(featurePath);
+  const normalisedPath = normaliseFeaturePath(featurePath);
+  const featureDir = getFeatureDir(fileSystem, normalisedPath);
+  const typeKey = type.toLowerCase();
+  const typeDirectory = TYPE_DIRECTORIES[typeKey];
+  const targetDirectory = path.join(featureDir, typeDirectory);
+  const importDirectory = `@src/${normalisedPath}/${typeDirectory}`;
+  return { targetDirectory, importDirectory };
+}
+function getRouteNameFromPath(routePath) {
+  const lastSegment = routePath.split("/").filter(Boolean).pop() || "index";
+  const cleanSegment = lastSegment.replace(/[:*]/g, "");
+  return `${toPascalCase(cleanSegment)}Page`;
+}
+
+// src/common/prisma.ts
+import {
+  getSchema
+} from "@mrleebo/prisma-ast";
+import fs2 from "fs";
+import path2 from "path";
+async function getEntityMetadata(modelName) {
+  try {
+    const schemaPath = path2.join(process.cwd(), "schema.prisma");
+    const schemaContent = fs2.readFileSync(schemaPath, "utf8");
+    const schema = getSchema(schemaContent);
+    const model = schema.list?.find(
+      (m) => m.type === "model" && m.name === modelName
+    );
+    if (!model || model.type !== "model") {
+      throw new Error(`Model ${modelName} not found in schema`);
+    }
+    const compositeIdAttr = (model.properties || []).find(
+      (item) => item.type === "attribute" && item.kind === "object" && item.name === "id"
+    );
+    let compositeIdFields = [];
+    if (compositeIdAttr?.args?.[0]) {
+      const arg = compositeIdAttr.args[0];
+      if (typeof arg.value === "object" && arg.value !== null && "type" in arg.value && arg.value.type === "array" && "args" in arg.value) {
+        compositeIdFields = arg.value.args;
+      }
+    }
+    const fields = (model.properties || []).filter(
+      (item) => item.type === "field" && !item.array && !item.attributes?.some((attr) => attr.name === "relation")
+    ).map((field) => {
+      const fieldType = typeof field.fieldType === "string" ? field.fieldType : field.fieldType.name;
+      const tsType = getPrismaToTsType(fieldType);
+      const isRequired = !field.optional;
+      const isId = field.attributes?.some((attr) => attr.name === "id") || compositeIdFields.includes(field.name);
+      const isUnique = field.attributes?.some((attr) => attr.name === "unique") || false;
+      const hasDefaultValue = field.attributes?.some((attr) => attr.name === "default") || false;
+      const isUpdatedAt = field.attributes?.some((attr) => attr.name === "updatedAt") || false;
+      const isGenerated = field.attributes?.some((attr) => attr.name === "map") || false;
+      return {
+        name: field.name,
+        type: fieldType,
+        tsType,
+        isRequired,
+        isId,
+        isUnique,
+        hasDefaultValue,
+        isGenerated,
+        isUpdatedAt
+      };
+    });
+    return {
+      name: modelName,
+      fields
+    };
+  } catch (error) {
+    throw new Error(
+      `Failed to get entity metadata for ${modelName}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function getIdFields(model) {
+  const idFields = model.fields.filter((f) => f.isId).map((f) => f.name);
+  if (idFields.length === 0) {
+    throw new Error(`No ID field found for model ${model.name}`);
+  }
+  return idFields;
+}
+function getRequiredFields(model) {
+  return model.fields.filter(
+    (f) => f.isRequired && !f.hasDefaultValue && !f.isGenerated && !f.isUpdatedAt
+  ).map((f) => f.name);
+}
+function getOptionalFields(model) {
+  return model.fields.filter(
+    (field) => (field.hasDefaultValue && field.type !== "DateTime" || !field.isRequired) && !field.isId && !field.isGenerated && !field.isUpdatedAt
+  ).map((field) => field.name);
+}
+function getJsonFields(model) {
+  return model.fields.filter((f) => f.type === "Json").map((f) => f.name);
+}
+function generateJsonTypeHandling(jsonFields) {
+  if (jsonFields.length === 0) return "";
+  const assignments = jsonFields.map(
+    (field) => `        ${field}: (data.${field} as Prisma.JsonValue) || Prisma.JsonNull`
+  ).join(",\n");
+  return `,
+${assignments}`;
+}
+function needsPrismaImport(model) {
+  return model.fields.some((f) => f.type === "Json" || f.type === "Decimal");
+}
+function generatePickType(modelName, fields, allFields) {
+  if (fields.length === 0) return "";
+  if (fields.length === allFields.length) return modelName;
+  const fieldUnion = fields.map((f) => `"${f}"`).join(" | ");
+  return `Pick<${modelName}, ${fieldUnion}>`;
+}
+function generateOmitType(modelName, fields, allFields) {
+  if (fields.length === 0) return modelName;
+  if (fields.length === allFields.length) return "";
+  const fieldUnion = fields.map((f) => `"${f}"`).join(" | ");
+  return `Omit<${modelName}, ${fieldUnion}>`;
+}
+function generatePartialType(typeString) {
+  if (!typeString) return "";
+  return `Partial<${typeString}>`;
+}
+function generateIntersectionType(type1, type2) {
+  if (!type1 && !type2) return "";
+  if (!type1) return type2;
+  if (!type2) return type1;
+  return `${type1} & ${type2}`;
+}
+function getPrismaToTsType(type) {
+  const typeMap = {
+    String: "string",
+    Int: "number",
+    Float: "number",
+    Boolean: "boolean",
+    DateTime: "Date",
+    Json: "Prisma.JsonValue",
+    BigInt: "bigint",
+    Decimal: "Prisma.Decimal",
+    Bytes: "Buffer"
+  };
+  return typeMap[type] || type;
+}
+
+// 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";
+import path3 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 = path3.dirname(templatePath);
+    const eta = new Eta({
+      autoTrim: false,
+      autoEscape: false,
+      views: templateDir,
+      functionHeader
+    });
+    const templateName = path3.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 = path3.dirname(currentFilePath);
+    const currentFileName = path3.basename(currentFilePath);
+    const isInstalledPackage = currentFileDir.includes("node_modules") && currentFileDir.endsWith("/dist") && currentFileName === "index.js";
+    const startDir = isInstalledPackage ? currentFileDir : path3.dirname(path3.dirname(currentFileDir));
+    return path3.join(
+      startDir,
+      "generators",
+      generatorDirName,
+      "templates",
+      relativePath
+    );
+  }
+};
+export {
+  TemplateUtility,
+  commonSchemas,
+  copyDirectory,
+  ensureDirectoryExists,
+  featureExists,
+  findWaspRoot,
+  generateIntersectionType,
+  generateJsonTypeHandling,
+  generateOmitType,
+  generatePartialType,
+  generatePickType,
+  getConfigDir,
+  getEntityMetadata,
+  getFeatureDir,
+  getFeatureImportPath,
+  getFeatureTargetDir,
+  getIdFields,
+  getJsonFields,
+  getOptionalFields,
+  getRequiredFields,
+  getRouteNameFromPath,
+  needsPrismaImport,
+  normaliseFeaturePath,
+  realFileSystem
+};

package/dist/common/prisma.js

@@ -0,0 +1,140 @@
+// src/common/prisma.ts
+import {
+  getSchema
+} from "@mrleebo/prisma-ast";
+import fs from "fs";
+import path from "path";
+async function getEntityMetadata(modelName) {
+  try {
+    const schemaPath = path.join(process.cwd(), "schema.prisma");
+    const schemaContent = fs.readFileSync(schemaPath, "utf8");
+    const schema = getSchema(schemaContent);
+    const model = schema.list?.find(
+      (m) => m.type === "model" && m.name === modelName
+    );
+    if (!model || model.type !== "model") {
+      throw new Error(`Model ${modelName} not found in schema`);
+    }
+    const compositeIdAttr = (model.properties || []).find(
+      (item) => item.type === "attribute" && item.kind === "object" && item.name === "id"
+    );
+    let compositeIdFields = [];
+    if (compositeIdAttr?.args?.[0]) {
+      const arg = compositeIdAttr.args[0];
+      if (typeof arg.value === "object" && arg.value !== null && "type" in arg.value && arg.value.type === "array" && "args" in arg.value) {
+        compositeIdFields = arg.value.args;
+      }
+    }
+    const fields = (model.properties || []).filter(
+      (item) => item.type === "field" && !item.array && !item.attributes?.some((attr) => attr.name === "relation")
+    ).map((field) => {
+      const fieldType = typeof field.fieldType === "string" ? field.fieldType : field.fieldType.name;
+      const tsType = getPrismaToTsType(fieldType);
+      const isRequired = !field.optional;
+      const isId = field.attributes?.some((attr) => attr.name === "id") || compositeIdFields.includes(field.name);
+      const isUnique = field.attributes?.some((attr) => attr.name === "unique") || false;
+      const hasDefaultValue = field.attributes?.some((attr) => attr.name === "default") || false;
+      const isUpdatedAt = field.attributes?.some((attr) => attr.name === "updatedAt") || false;
+      const isGenerated = field.attributes?.some((attr) => attr.name === "map") || false;
+      return {
+        name: field.name,
+        type: fieldType,
+        tsType,
+        isRequired,
+        isId,
+        isUnique,
+        hasDefaultValue,
+        isGenerated,
+        isUpdatedAt
+      };
+    });
+    return {
+      name: modelName,
+      fields
+    };
+  } catch (error) {
+    throw new Error(
+      `Failed to get entity metadata for ${modelName}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function getIdFields(model) {
+  const idFields = model.fields.filter((f) => f.isId).map((f) => f.name);
+  if (idFields.length === 0) {
+    throw new Error(`No ID field found for model ${model.name}`);
+  }
+  return idFields;
+}
+function getRequiredFields(model) {
+  return model.fields.filter(
+    (f) => f.isRequired && !f.hasDefaultValue && !f.isGenerated && !f.isUpdatedAt
+  ).map((f) => f.name);
+}
+function getOptionalFields(model) {
+  return model.fields.filter(
+    (field) => (field.hasDefaultValue && field.type !== "DateTime" || !field.isRequired) && !field.isId && !field.isGenerated && !field.isUpdatedAt
+  ).map((field) => field.name);
+}
+function getJsonFields(model) {
+  return model.fields.filter((f) => f.type === "Json").map((f) => f.name);
+}
+function generateJsonTypeHandling(jsonFields) {
+  if (jsonFields.length === 0) return "";
+  const assignments = jsonFields.map(
+    (field) => `        ${field}: (data.${field} as Prisma.JsonValue) || Prisma.JsonNull`
+  ).join(",\n");
+  return `,
+${assignments}`;
+}
+function needsPrismaImport(model) {
+  return model.fields.some((f) => f.type === "Json" || f.type === "Decimal");
+}
+function generatePickType(modelName, fields, allFields) {
+  if (fields.length === 0) return "";
+  if (fields.length === allFields.length) return modelName;
+  const fieldUnion = fields.map((f) => `"${f}"`).join(" | ");
+  return `Pick<${modelName}, ${fieldUnion}>`;
+}
+function generateOmitType(modelName, fields, allFields) {
+  if (fields.length === 0) return modelName;
+  if (fields.length === allFields.length) return "";
+  const fieldUnion = fields.map((f) => `"${f}"`).join(" | ");
+  return `Omit<${modelName}, ${fieldUnion}>`;
+}
+function generatePartialType(typeString) {
+  if (!typeString) return "";
+  return `Partial<${typeString}>`;
+}
+function generateIntersectionType(type1, type2) {
+  if (!type1 && !type2) return "";
+  if (!type1) return type2;
+  if (!type2) return type1;
+  return `${type1} & ${type2}`;
+}
+function getPrismaToTsType(type) {
+  const typeMap = {
+    String: "string",
+    Int: "number",
+    Float: "number",
+    Boolean: "boolean",
+    DateTime: "Date",
+    Json: "Prisma.JsonValue",
+    BigInt: "bigint",
+    Decimal: "Prisma.Decimal",
+    Bytes: "Buffer"
+  };
+  return typeMap[type] || type;
+}
+export {
+  generateIntersectionType,
+  generateJsonTypeHandling,
+  generateOmitType,
+  generatePartialType,
+  generatePickType,
+  getEntityMetadata,
+  getIdFields,
+  getJsonFields,
+  getOptionalFields,
+  getRequiredFields,
+  needsPrismaImport
+};