@famgia/omnify-laravel 0.0.12 → 0.0.13

package/dist/plugin.cjs

@@ -684,491 +684,16 @@ function getMigrationPath(migration, outputDir = "database/migrations") {
   return `${outputDir}/${migration.fileName}`;
 }
 
-// src/typescript/interface-generator.ts
-var TYPE_MAP = {
-  String: "string",
-  Int: "number",
-  BigInt: "number",
-  Float: "number",
-  Boolean: "boolean",
-  Text: "string",
-  LongText: "string",
-  Date: "string",
-  Time: "string",
-  Timestamp: "string",
-  Json: "unknown",
-  Email: "string",
-  Password: "string",
-  Enum: "string",
-  Select: "string",
-  Lookup: "number"
-};
-var FILE_INTERFACE_NAME = "File";
-var PK_TYPE_MAP = {
-  Int: "number",
-  BigInt: "number",
-  Uuid: "string",
-  String: "string"
-};
-function toPropertyName(name) {
-  return name;
-}
-function toInterfaceName(schemaName) {
-  return schemaName;
-}
-function getPropertyType(property, _allSchemas) {
-  if (property.type === "File") {
-    const fileProp = property;
-    if (fileProp.multiple) {
-      return `${FILE_INTERFACE_NAME}[]`;
-    }
-    return `${FILE_INTERFACE_NAME} | null`;
-  }
-  if (property.type === "Association") {
-    const assocProp = property;
-    const targetName = assocProp.target ?? "unknown";
-    switch (assocProp.relation) {
-      // Standard relations
-      case "OneToOne":
-      case "ManyToOne":
-        return targetName;
-      case "OneToMany":
-      case "ManyToMany":
-        return `${targetName}[]`;
-      // Polymorphic relations
-      case "MorphTo":
-        if (assocProp.targets && assocProp.targets.length > 0) {
-          return assocProp.targets.join(" | ");
-        }
-        return "unknown";
-      case "MorphOne":
-        return targetName;
-      case "MorphMany":
-      case "MorphToMany":
-      case "MorphedByMany":
-        return `${targetName}[]`;
-      default:
-        return "unknown";
-    }
-  }
-  if (property.type === "Enum") {
-    const enumProp = property;
-    if (typeof enumProp.enum === "string") {
-      return enumProp.enum;
-    }
-    if (Array.isArray(enumProp.enum)) {
-      return enumProp.enum.map((v) => `'${v}'`).join(" | ");
-    }
-  }
-  if (property.type === "Select") {
-    const selectProp = property;
-    if (selectProp.options && selectProp.options.length > 0) {
-      return selectProp.options.map((v) => `'${v}'`).join(" | ");
-    }
-  }
-  return TYPE_MAP[property.type] ?? "unknown";
-}
-function propertyToTSProperties(propertyName, property, allSchemas, options = {}) {
-  const baseProp = property;
-  const isReadonly = options.readonly ?? true;
-  if (property.type === "Association") {
-    const assocProp = property;
-    if (assocProp.relation === "MorphTo" && assocProp.targets && assocProp.targets.length > 0) {
-      const propBaseName = toPropertyName(propertyName);
-      const targetUnion = assocProp.targets.map((t) => `'${t}'`).join(" | ");
-      const relationUnion = assocProp.targets.join(" | ");
-      return [
-        {
-          name: `${propBaseName}Type`,
-          type: targetUnion,
-          optional: true,
-          // Polymorphic columns are nullable
-          readonly: isReadonly,
-          comment: `Polymorphic type for ${propertyName}`
-        },
-        {
-          name: `${propBaseName}Id`,
-          type: "number",
-          optional: true,
-          readonly: isReadonly,
-          comment: `Polymorphic ID for ${propertyName}`
-        },
-        {
-          name: propBaseName,
-          type: `${relationUnion} | null`,
-          optional: true,
-          readonly: isReadonly,
-          comment: baseProp.displayName ?? `Polymorphic relation to ${assocProp.targets.join(", ")}`
-        }
-      ];
-    }
-  }
-  const type = getPropertyType(property, allSchemas);
-  return [{
-    name: toPropertyName(propertyName),
-    type,
-    optional: baseProp.nullable ?? false,
-    readonly: isReadonly,
-    comment: baseProp.displayName
-  }];
-}
-function schemaToInterface(schema, allSchemas, options = {}) {
-  const properties = [];
-  if (schema.options?.id !== false) {
-    const pkType = schema.options?.idType ?? "BigInt";
-    properties.push({
-      name: "id",
-      type: PK_TYPE_MAP[pkType] ?? "number",
-      optional: false,
-      readonly: options.readonly ?? true,
-      comment: "Primary key"
-    });
-  }
-  if (schema.properties) {
-    for (const [propName, property] of Object.entries(schema.properties)) {
-      properties.push(...propertyToTSProperties(propName, property, allSchemas, options));
-    }
-  }
-  if (schema.options?.timestamps !== false) {
-    properties.push(
-      {
-        name: "createdAt",
-        type: "string",
-        optional: true,
-        readonly: options.readonly ?? true,
-        comment: "Creation timestamp"
-      },
-      {
-        name: "updatedAt",
-        type: "string",
-        optional: true,
-        readonly: options.readonly ?? true,
-        comment: "Last update timestamp"
-      }
-    );
-  }
-  if (schema.options?.softDelete) {
-    properties.push({
-      name: "deletedAt",
-      type: "string",
-      optional: true,
-      readonly: options.readonly ?? true,
-      comment: "Soft delete timestamp"
-    });
-  }
-  return {
-    name: toInterfaceName(schema.name),
-    properties,
-    comment: schema.displayName ?? schema.name
-  };
-}
-function formatProperty(property) {
-  const readonly = property.readonly ? "readonly " : "";
-  const optional = property.optional ? "?" : "";
-  const comment = property.comment ? `  /** ${property.comment} */
-` : "";
-  return `${comment}  ${readonly}${property.name}${optional}: ${property.type};`;
-}
-function formatInterface(iface) {
-  const comment = iface.comment ? `/**
- * ${iface.comment}
- */
-` : "";
-  const extendsClause = iface.extends && iface.extends.length > 0 ? ` extends ${iface.extends.join(", ")}` : "";
-  const properties = iface.properties.map(formatProperty).join("\n");
-  return `${comment}export interface ${iface.name}${extendsClause} {
-${properties}
-}`;
-}
-function generateInterfaces(schemas, options = {}) {
-  const interfaces = [];
-  for (const schema of Object.values(schemas)) {
-    if (schema.kind === "enum") {
-      continue;
-    }
-    interfaces.push(schemaToInterface(schema, schemas, options));
-  }
-  return interfaces;
-}
-
-// src/typescript/enum-generator.ts
-function toEnumMemberName(value) {
-  return value.split(/[-_\s]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("").replace(/[^a-zA-Z0-9]/g, "");
-}
-function toEnumName(schemaName) {
-  return schemaName;
-}
-function schemaToEnum(schema) {
-  if (schema.kind !== "enum" || !schema.values) {
-    return null;
-  }
-  const values = schema.values.map((value) => ({
-    name: toEnumMemberName(value),
-    value
-  }));
-  return {
-    name: toEnumName(schema.name),
-    values,
-    comment: schema.displayName ?? schema.name
-  };
-}
-function generateEnums(schemas) {
-  const enums = [];
-  for (const schema of Object.values(schemas)) {
-    if (schema.kind === "enum") {
-      const enumDef = schemaToEnum(schema);
-      if (enumDef) {
-        enums.push(enumDef);
-      }
-    }
-  }
-  return enums;
-}
-function formatEnum(enumDef) {
-  const comment = enumDef.comment ? `/**
- * ${enumDef.comment}
- */
-` : "";
-  const values = enumDef.values.map((v) => `  ${v.name} = '${v.value}',`).join("\n");
-  return `${comment}export enum ${enumDef.name} {
-${values}
-}`;
-}
-function formatTypeAlias(alias) {
-  const comment = alias.comment ? `/**
- * ${alias.comment}
- */
-` : "";
-  return `${comment}export type ${alias.name} = ${alias.type};`;
-}
-function extractInlineEnums(schemas) {
-  const typeAliases = [];
-  for (const schema of Object.values(schemas)) {
-    if (schema.kind === "enum" || !schema.properties) {
-      continue;
-    }
-    for (const [propName, property] of Object.entries(schema.properties)) {
-      if (property.type === "Enum") {
-        const enumProp = property;
-        if (Array.isArray(enumProp.enum) && enumProp.enum.length > 0) {
-          const typeName = `${schema.name}${propName.charAt(0).toUpperCase() + propName.slice(1)}`;
-          typeAliases.push({
-            name: typeName,
-            type: enumProp.enum.map((v) => `'${v}'`).join(" | "),
-            comment: enumProp.displayName ?? `${schema.name} ${propName} enum`
-          });
-        }
-      }
-      if (property.type === "Select") {
-        const selectProp = property;
-        if (selectProp.options && selectProp.options.length > 0) {
-          const typeName = `${schema.name}${propName.charAt(0).toUpperCase() + propName.slice(1)}`;
-          typeAliases.push({
-            name: typeName,
-            type: selectProp.options.map((v) => `'${v}'`).join(" | "),
-            comment: selectProp.displayName ?? `${schema.name} ${propName} options`
-          });
-        }
-      }
-    }
-  }
-  return typeAliases;
-}
-
-// src/typescript/generator.ts
-var DEFAULT_OPTIONS = {
-  singleFile: true,
-  fileName: "types.ts",
-  readonly: true,
-  strictNullChecks: true
-};
-function generateHeader() {
-  return `/**
- * Auto-generated TypeScript types from Omnify schemas.
- * DO NOT EDIT - This file is automatically generated.
- */
-
-`;
-}
-function generateTypeScriptFile(schemas, options = {}) {
-  const opts = { ...DEFAULT_OPTIONS, ...options };
-  const parts = [generateHeader()];
-  const types = [];
-  const enums = generateEnums(schemas);
-  if (enums.length > 0) {
-    parts.push("// Enums\n");
-    for (const enumDef of enums) {
-      parts.push(formatEnum(enumDef));
-      parts.push("\n\n");
-      types.push(enumDef.name);
-    }
-  }
-  const inlineEnums = extractInlineEnums(schemas);
-  if (inlineEnums.length > 0) {
-    parts.push("// Type Aliases\n");
-    for (const alias of inlineEnums) {
-      parts.push(formatTypeAlias(alias));
-      parts.push("\n\n");
-      types.push(alias.name);
-    }
-  }
-  const interfaces = generateInterfaces(schemas, opts);
-  if (interfaces.length > 0) {
-    parts.push("// Interfaces\n");
-    for (const iface of interfaces) {
-      parts.push(formatInterface(iface));
-      parts.push("\n\n");
-      types.push(iface.name);
-    }
-  }
-  return {
-    fileName: opts.fileName ?? "types.ts",
-    content: parts.join("").trim() + "\n",
-    types
-  };
-}
-function generateTypeScriptFiles(schemas, options = {}) {
-  const opts = { ...DEFAULT_OPTIONS, ...options };
-  const files = [];
-  const enums = generateEnums(schemas);
-  if (enums.length > 0) {
-    const content = generateHeader() + enums.map(formatEnum).join("\n\n") + "\n";
-    files.push({
-      fileName: "enums.ts",
-      content,
-      types: enums.map((e) => e.name)
-    });
-  }
-  const inlineEnums = extractInlineEnums(schemas);
-  if (inlineEnums.length > 0) {
-    const content = generateHeader() + inlineEnums.map(formatTypeAlias).join("\n\n") + "\n";
-    files.push({
-      fileName: "type-aliases.ts",
-      content,
-      types: inlineEnums.map((a) => a.name)
-    });
-  }
-  const interfaces = generateInterfaces(schemas, opts);
-  for (const iface of interfaces) {
-    const imports = collectImports(iface, enums, inlineEnums, interfaces);
-    const importStatement = formatImports(imports);
-    const content = generateHeader() + (importStatement ? importStatement + "\n\n" : "") + formatInterface(iface) + "\n";
-    files.push({
-      fileName: `${toKebabCase(iface.name)}.ts`,
-      content,
-      types: [iface.name]
-    });
-  }
-  const indexContent = generateIndexFile(files);
-  files.push({
-    fileName: "index.ts",
-    content: indexContent,
-    types: []
-  });
-  return files;
-}
-function toKebabCase(name) {
-  return name.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "");
-}
-function collectImports(iface, enums, typeAliases, allInterfaces) {
-  const imports = /* @__PURE__ */ new Map();
-  const enumNames = new Set(enums.map((e) => e.name));
-  const aliasNames = new Set(typeAliases.map((a) => a.name));
-  const interfaceNames = new Set(allInterfaces.map((i) => i.name));
-  for (const prop of iface.properties) {
-    if (enumNames.has(prop.type)) {
-      const existing = imports.get("./enums.js") ?? [];
-      if (!existing.includes(prop.type)) {
-        imports.set("./enums.js", [...existing, prop.type]);
-      }
-    }
-    if (aliasNames.has(prop.type)) {
-      const existing = imports.get("./type-aliases.js") ?? [];
-      if (!existing.includes(prop.type)) {
-        imports.set("./type-aliases.js", [...existing, prop.type]);
-      }
-    }
-    const baseType = prop.type.replace("[]", "");
-    if (interfaceNames.has(baseType) && baseType !== iface.name) {
-      const fileName = `./${toKebabCase(baseType)}.js`;
-      const existing = imports.get(fileName) ?? [];
-      if (!existing.includes(baseType)) {
-        imports.set(fileName, [...existing, baseType]);
-      }
-    }
-  }
-  return imports;
-}
-function formatImports(imports) {
-  if (imports.size === 0) return "";
-  const lines = [];
-  for (const [path, names] of imports) {
-    lines.push(`import type { ${names.join(", ")} } from '${path}';`);
-  }
-  return lines.join("\n");
-}
-function generateIndexFile(files) {
-  const exports2 = [generateHeader().trim(), ""];
-  for (const file of files) {
-    if (file.fileName === "index.ts") continue;
-    const moduleName = file.fileName.replace(".ts", ".js");
-    exports2.push(`export * from './${moduleName}';`);
-  }
-  return exports2.join("\n") + "\n";
-}
-function generateTypeScript(schemas, options = {}) {
-  const opts = { ...DEFAULT_OPTIONS, ...options };
-  if (opts.singleFile) {
-    return [generateTypeScriptFile(schemas, opts)];
-  }
-  return generateTypeScriptFiles(schemas, opts);
-}
-
 // src/plugin.ts
 var LARAVEL_CONFIG_SCHEMA = {
   fields: [
-    // Paths group
     {
       key: "migrationsPath",
       type: "path",
       label: "Migrations Path",
       description: "Directory for Laravel migration files",
       default: "database/migrations",
-      group: "paths"
-    },
-    {
-      key: "typesPath",
-      type: "path",
-      label: "TypeScript Types Path",
-      description: "Directory for generated TypeScript type files",
-      default: "types",
-      group: "paths"
-    },
-    // Generators group
-    {
-      key: "generateMigrations",
-      type: "boolean",
-      label: "Generate Migrations",
-      description: "Generate Laravel migration files",
-      default: true,
-      group: "generators"
-    },
-    {
-      key: "generateTypes",
-      type: "boolean",
-      label: "Generate TypeScript Types",
-      description: "Generate TypeScript type definitions",
-      default: true,
-      group: "generators"
-    },
-    // Options group
-    {
-      key: "singleFile",
-      type: "boolean",
-      label: "Single File Output",
-      description: "Generate all types in a single file",
-      default: true,
-      group: "options"
+      group: "output"
     },
     {
       key: "connection",
@@ -1183,65 +708,37 @@ var LARAVEL_CONFIG_SCHEMA = {
 function resolveOptions(options) {
   return {
     migrationsPath: options?.migrationsPath ?? "database/migrations",
-    typesPath: options?.typesPath ?? "types",
-    singleFile: options?.singleFile ?? true,
     connection: options?.connection,
-    timestamp: options?.timestamp,
-    generateTypes: options?.generateTypes ?? true,
-    generateMigrations: options?.generateMigrations ?? true
+    timestamp: options?.timestamp
   };
 }
 function laravelPlugin(options) {
   const resolved = resolveOptions(options);
   return {
     name: "@famgia/omnify-laravel",
-    version: "0.0.12",
+    version: "0.0.13",
     configSchema: LARAVEL_CONFIG_SCHEMA,
     generators: [
-      // Laravel Migrations Generator
-      ...resolved.generateMigrations ? [
-        {
-          name: "laravel-migrations",
-          description: "Generate Laravel migration files",
-          generate: async (ctx) => {
-            const migrationOptions = {
-              connection: resolved.connection,
-              timestamp: resolved.timestamp
-            };
-            const migrations = generateMigrations(ctx.schemas, migrationOptions);
-            return migrations.map((migration) => ({
-              path: getMigrationPath(migration, resolved.migrationsPath),
-              content: migration.content,
-              type: "migration",
-              metadata: {
-                tableName: migration.tables[0],
-                migrationType: migration.type
-              }
-            }));
-          }
-        }
-      ] : [],
-      // TypeScript Types Generator
-      ...resolved.generateTypes ? [
-        {
-          name: "typescript-types",
-          description: "Generate TypeScript type definitions",
-          generate: async (ctx) => {
-            const tsOptions = {
-              singleFile: resolved.singleFile
-            };
-            const files = generateTypeScript(ctx.schemas, tsOptions);
-            return files.map((file) => ({
-              path: `${resolved.typesPath}/${file.fileName}`,
-              content: file.content,
-              type: "type",
-              metadata: {
-                types: file.types
-              }
-            }));
-          }
+      {
+        name: "laravel-migrations",
+        description: "Generate Laravel migration files",
+        generate: async (ctx) => {
+          const migrationOptions = {
+            connection: resolved.connection,
+            timestamp: resolved.timestamp
+          };
+          const migrations = generateMigrations(ctx.schemas, migrationOptions);
+          return migrations.map((migration) => ({
+            path: getMigrationPath(migration, resolved.migrationsPath),
+            content: migration.content,
+            type: "migration",
+            metadata: {
+              tableName: migration.tables[0],
+              migrationType: migration.type
+            }
+          }));
         }
-      ] : []
+      }
     ]
   };
 }