@famgia/omnify-laravel 0.0.17 → 0.0.18

package/dist/index.cjs

@@ -55,6 +55,7 @@ var TYPE_METHOD_MAP = {
   LongText: "longText",
   Date: "date",
   Time: "time",
+  DateTime: "dateTime",
   Timestamp: "timestamp",
   Json: "json",
   Email: "string",
@@ -127,6 +128,10 @@ function propertyToColumnMethod(propertyName, property) {
   if (baseProp.unsigned && (method === "integer" || method === "bigInteger")) {
     modifiers.push({ method: "unsigned" });
   }
+  const displayName = property.displayName;
+  if (displayName) {
+    modifiers.push({ method: "comment", args: [displayName] });
+  }
   return {
     name: columnName,
     method,
@@ -261,6 +266,9 @@ function generateForeignKey(propertyName, property, allSchemas) {
   if (assocProp.default !== void 0 && assocProp.default !== null) {
     modifiers.push({ method: "default", args: [assocProp.default] });
   }
+  if (assocProp.displayName) {
+    modifiers.push({ method: "comment", args: [assocProp.displayName] });
+  }
   const column = {
     name: columnName,
     method,
@@ -280,7 +288,65 @@ function generateForeignKey(propertyName, property, allSchemas) {
   };
   return { column, foreignKey, index };
 }
-function schemaToBlueprint(schema, allSchemas) {
+function expandCompoundType(propName, property, customTypes) {
+  const typeDef = customTypes.get(property.type);
+  if (!typeDef || !typeDef.compound || !typeDef.expand) {
+    return null;
+  }
+  const expanded = [];
+  const baseProp = property;
+  for (const field of typeDef.expand) {
+    const suffixSnake = toColumnName(field.suffix);
+    const columnName = `${propName}_${suffixSnake}`;
+    const expandedProp = {
+      type: "String"
+      // Default type, will be overridden by sql definition
+    };
+    if (field.sql) {
+      const sqlType = field.sql.sqlType.toUpperCase();
+      if (sqlType === "VARCHAR" || sqlType === "CHAR" || sqlType === "STRING") {
+        expandedProp.type = "String";
+        if (field.sql.length) {
+          expandedProp.length = field.sql.length;
+        }
+      } else if (sqlType === "INT" || sqlType === "INTEGER") {
+        expandedProp.type = "Int";
+      } else if (sqlType === "BIGINT") {
+        expandedProp.type = "BigInt";
+      } else if (sqlType === "TEXT") {
+        expandedProp.type = "Text";
+      } else if (sqlType === "BOOLEAN" || sqlType === "BOOL") {
+        expandedProp.type = "Boolean";
+      } else if (sqlType === "DECIMAL") {
+        expandedProp.type = "Decimal";
+        if (field.sql.precision) expandedProp.precision = field.sql.precision;
+        if (field.sql.scale) expandedProp.scale = field.sql.scale;
+      } else if (sqlType === "DATE") {
+        expandedProp.type = "Date";
+      } else if (sqlType === "TIMESTAMP" || sqlType === "DATETIME") {
+        expandedProp.type = "Timestamp";
+      }
+      if (field.sql.nullable !== void 0) {
+        expandedProp.nullable = field.sql.nullable;
+      } else if (baseProp.nullable !== void 0) {
+        expandedProp.nullable = baseProp.nullable;
+      }
+      if (field.sql.default !== void 0) {
+        expandedProp.default = field.sql.default;
+      }
+    }
+    if (baseProp.displayName) {
+      expandedProp.displayName = `${baseProp.displayName} (${field.suffix})`;
+    }
+    expanded.push({
+      name: columnName,
+      property: expandedProp
+    });
+  }
+  return expanded;
+}
+function schemaToBlueprint(schema, allSchemas, options = {}) {
+  const { customTypes = /* @__PURE__ */ new Map() } = options;
   const tableName = toTableName(schema.name);
   const columns = [];
   const foreignKeys = [];
@@ -291,6 +357,16 @@ function schemaToBlueprint(schema, allSchemas) {
   }
   if (schema.properties) {
     for (const [propName, property] of Object.entries(schema.properties)) {
+      const expandedProps = expandCompoundType(propName, property, customTypes);
+      if (expandedProps) {
+        for (const { name: expandedName, property: expandedProp } of expandedProps) {
+          const columnMethod2 = propertyToColumnMethod(expandedName, expandedProp);
+          if (columnMethod2) {
+            columns.push(columnMethod2);
+          }
+        }
+        continue;
+      }
       const columnMethod = propertyToColumnMethod(propName, property);
       if (columnMethod) {
         columns.push(columnMethod);
@@ -737,7 +813,9 @@ function generateMigrations(schemas, options = {}) {
     const timestamp = options.timestamp ?? generateTimestamp();
     const offsetTimestamp = incrementTimestamp(timestamp, timestampOffset);
     timestampOffset++;
-    const blueprint = schemaToBlueprint(schema, schemas);
+    const blueprint = schemaToBlueprint(schema, schemas, {
+      customTypes: options.customTypes
+    });
     const migration = generateCreateMigration(blueprint, {
       ...options,
       timestamp: offsetTimestamp
@@ -815,6 +893,7 @@ var TYPE_METHOD_MAP2 = {
   LongText: "longText",
   Date: "date",
   Time: "time",
+  DateTime: "dateTime",
   Timestamp: "timestamp",
   Json: "json",
   Email: "string",
@@ -2099,6 +2178,24 @@ function getFactoryPath(factory) {
 }
 
 // src/plugin.ts
+function getExistingMigrationTables(migrationsDir) {
+  const existingTables = /* @__PURE__ */ new Set();
+  if (!(0, import_node_fs.existsSync)(migrationsDir)) {
+    return existingTables;
+  }
+  try {
+    const files = (0, import_node_fs.readdirSync)(migrationsDir);
+    const createMigrationPattern = /^\d{4}_\d{2}_\d{2}_\d{6}_create_(.+)_table\.php$/;
+    for (const file of files) {
+      const match = file.match(createMigrationPattern);
+      if (match) {
+        existingTables.add(match[1]);
+      }
+    }
+  } catch {
+  }
+  return existingTables;
+}
 var LARAVEL_CONFIG_SCHEMA = {
   fields: [
     {
@@ -2182,18 +2279,81 @@ function laravelPlugin(options) {
     generate: async (ctx) => {
       const migrationOptions = {
         connection: resolved.connection,
-        timestamp: resolved.timestamp
+        timestamp: resolved.timestamp,
+        customTypes: ctx.customTypes
       };
-      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
+      const outputs = [];
+      const migrationsDir = (0, import_node_path.join)(ctx.cwd, resolved.migrationsPath);
+      const existingTables = getExistingMigrationTables(migrationsDir);
+      if (ctx.changes !== void 0) {
+        if (ctx.changes.length === 0) {
+          return outputs;
         }
-      }));
+        const addedSchemaNames = new Set(
+          ctx.changes.filter((c) => c.changeType === "added").map((c) => c.schemaName)
+        );
+        if (addedSchemaNames.size > 0) {
+          const addedSchemas = Object.fromEntries(
+            Object.entries(ctx.schemas).filter(([name]) => addedSchemaNames.has(name))
+          );
+          const createMigrations = generateMigrations(addedSchemas, migrationOptions);
+          for (const migration of createMigrations) {
+            const tableName = migration.tables[0];
+            if (existingTables.has(tableName)) {
+              ctx.logger.debug(`Skipping CREATE for ${tableName} (already exists)`);
+              continue;
+            }
+            outputs.push({
+              path: getMigrationPath(migration, resolved.migrationsPath),
+              content: migration.content,
+              type: "migration",
+              metadata: {
+                tableName,
+                migrationType: "create"
+              }
+            });
+          }
+        }
+        const alterChanges = ctx.changes.filter(
+          (c) => c.changeType === "modified" || c.changeType === "removed"
+        );
+        if (alterChanges.length > 0) {
+          const alterMigrations = generateMigrationsFromChanges(
+            alterChanges,
+            migrationOptions
+          );
+          for (const migration of alterMigrations) {
+            outputs.push({
+              path: getMigrationPath(migration, resolved.migrationsPath),
+              content: migration.content,
+              type: "migration",
+              metadata: {
+                tableName: migration.tables[0],
+                migrationType: migration.type
+              }
+            });
+          }
+        }
+      } else {
+        const migrations = generateMigrations(ctx.schemas, migrationOptions);
+        for (const migration of migrations) {
+          const tableName = migration.tables[0];
+          if (migration.type === "create" && existingTables.has(tableName)) {
+            ctx.logger.debug(`Skipping migration for ${tableName} (already exists)`);
+            continue;
+          }
+          outputs.push({
+            path: getMigrationPath(migration, resolved.migrationsPath),
+            content: migration.content,
+            type: "migration",
+            metadata: {
+              tableName,
+              migrationType: migration.type
+            }
+          });
+        }
+      }
+      return outputs;
     }
   };
   const modelGenerator = {