@magnet-cms/plugin-playground 2.0.0

package/dist/backend/index.cjs

@@ -0,0 +1,1023 @@
+'use strict';
+
+var common = require('@nestjs/common');
+var core = require('@magnet-cms/core');
+var fs = require('fs');
+var path = require('path');
+var common$1 = require('@magnet-cms/common');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+var PlaygroundService = class _PlaygroundService {
+  static {
+    __name(this, "PlaygroundService");
+  }
+  magnetOptions;
+  pluginOptions;
+  logger;
+  constructor(magnetOptions, pluginOptions) {
+    this.magnetOptions = magnetOptions;
+    this.pluginOptions = pluginOptions;
+    this.logger = new common.Logger(_PlaygroundService.name);
+  }
+  /**
+  * Get the modules directory path from options or use default.
+  * When MAGNET_PLAYGROUND_MODULES_PATH is set (e.g. for e2e), use it so
+  * generated modules are not written into the app's src/modules.
+  */
+  getModulesDir() {
+    const envPath = process.env.MAGNET_PLAYGROUND_MODULES_PATH;
+    if (envPath?.trim()) {
+      return path__namespace.resolve(envPath.trim());
+    }
+    if (this.pluginOptions?.modulesPath) {
+      return this.pluginOptions.modulesPath;
+    }
+    const opts = this.magnetOptions;
+    return opts?.playground?.modulesPath || opts?.playground?.schemasPath || path__namespace.join(process.cwd(), "src", "modules");
+  }
+  /**
+  * List all schemas by scanning module directories
+  */
+  async listSchemas() {
+    const modulesDir = this.getModulesDir();
+    if (!fs__namespace.existsSync(modulesDir)) {
+      return [];
+    }
+    const schemas = [];
+    const entries = fs__namespace.readdirSync(modulesDir, {
+      withFileTypes: true
+    });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const schemaFile = path__namespace.join(modulesDir, entry.name, `${entry.name}.schema.ts`);
+      const schemaFileAlt = path__namespace.join(modulesDir, entry.name, "schemas", `${entry.name}.schema.ts`);
+      const filePath = fs__namespace.existsSync(schemaFile) ? schemaFile : fs__namespace.existsSync(schemaFileAlt) ? schemaFileAlt : null;
+      if (!filePath) continue;
+      const content = fs__namespace.readFileSync(filePath, "utf-8");
+      const parsed = this.parseSchemaFile(content);
+      if (parsed) {
+        const stats = fs__namespace.statSync(filePath);
+        schemas.push({
+          name: parsed.name,
+          apiId: parsed.name.toLowerCase(),
+          fieldCount: parsed.fields.length,
+          hasVersioning: parsed.options?.versioning ?? true,
+          hasI18n: parsed.options?.i18n ?? true,
+          createdAt: stats.birthtime,
+          updatedAt: stats.mtime
+        });
+      }
+    }
+    return schemas;
+  }
+  /**
+  * Get a schema by name
+  */
+  async getSchema(name) {
+    const modulesDir = this.getModulesDir();
+    const lowerName = name.toLowerCase();
+    const schemaFile = path__namespace.join(modulesDir, lowerName, `${lowerName}.schema.ts`);
+    const schemaFileAlt = path__namespace.join(modulesDir, lowerName, "schemas", `${lowerName}.schema.ts`);
+    const filePath = fs__namespace.existsSync(schemaFile) ? schemaFile : fs__namespace.existsSync(schemaFileAlt) ? schemaFileAlt : null;
+    if (!filePath) {
+      return null;
+    }
+    const content = fs__namespace.readFileSync(filePath, "utf-8");
+    const parsed = this.parseSchemaFile(content);
+    if (!parsed) {
+      return null;
+    }
+    return {
+      name: parsed.name,
+      apiId: parsed.name.toLowerCase(),
+      options: parsed.options || {
+        versioning: true,
+        i18n: true
+      },
+      fields: parsed.fields,
+      generatedCode: content
+    };
+  }
+  /**
+  * Check if a schema/module already exists
+  */
+  schemaExists(name) {
+    const modulesDir = this.getModulesDir();
+    const lowerName = name.toLowerCase();
+    const moduleDir = path__namespace.join(modulesDir, lowerName);
+    return fs__namespace.existsSync(moduleDir);
+  }
+  /**
+  * Create a new module with all files (schema, controller, service, module, dto)
+  */
+  async createModule(dto) {
+    const modulesDir = this.getModulesDir();
+    const lowerName = dto.name.toLowerCase();
+    const moduleDir = path__namespace.join(modulesDir, lowerName);
+    const dtoDir = path__namespace.join(moduleDir, "dto");
+    fs__namespace.mkdirSync(dtoDir, {
+      recursive: true
+    });
+    const createdFiles = [];
+    const schemaCode = this.generateSchemaCode(dto);
+    const files = [
+      {
+        name: `${lowerName}.schema.ts`,
+        content: schemaCode
+      },
+      {
+        name: `${lowerName}.module.ts`,
+        content: this.generateModuleCode(dto.name)
+      },
+      {
+        name: `${lowerName}.controller.ts`,
+        content: this.generateControllerCode(dto.name)
+      },
+      {
+        name: `${lowerName}.service.ts`,
+        content: this.generateServiceCode(dto.name)
+      },
+      {
+        name: `dto/create-${lowerName}.dto.ts`,
+        content: this.generateDtoCode(dto.name, dto.fields)
+      }
+    ];
+    for (const file of files) {
+      const filePath = path__namespace.join(moduleDir, file.name);
+      fs__namespace.writeFileSync(filePath, file.content, "utf-8");
+      createdFiles.push(filePath);
+      this.logger.log(`Created: ${filePath}`);
+    }
+    return {
+      name: dto.name,
+      apiId: lowerName,
+      options: dto.options || {
+        versioning: true,
+        i18n: true
+      },
+      fields: dto.fields,
+      generatedCode: schemaCode,
+      createdFiles,
+      message: `Module "${dto.name}" created successfully. Import ${dto.name}Module in your app.module.ts to use it.`
+    };
+  }
+  /**
+  * Update only the schema file for an existing module
+  */
+  async updateSchema(name, dto) {
+    const modulesDir = this.getModulesDir();
+    const lowerName = name.toLowerCase();
+    const schemaFile = path__namespace.join(modulesDir, lowerName, `${lowerName}.schema.ts`);
+    const schemaFileAlt = path__namespace.join(modulesDir, lowerName, "schemas", `${lowerName}.schema.ts`);
+    const filePath = fs__namespace.existsSync(schemaFile) ? schemaFile : fs__namespace.existsSync(schemaFileAlt) ? schemaFileAlt : null;
+    if (!filePath) {
+      throw new Error(`Schema "${name}" not found`);
+    }
+    const existingContent = fs__namespace.readFileSync(filePath, "utf-8");
+    const existingParsed = this.parseSchemaFile(existingContent);
+    const conflicts = existingParsed ? this.detectConflicts(existingParsed.fields, dto.fields) : [];
+    const newCode = this.generateSchemaCode(dto);
+    fs__namespace.writeFileSync(filePath, newCode, "utf-8");
+    this.logger.log(`Schema updated: ${filePath}`);
+    return {
+      detail: {
+        name: dto.name,
+        apiId: dto.name.toLowerCase(),
+        options: dto.options || {
+          versioning: true,
+          i18n: true
+        },
+        fields: dto.fields,
+        generatedCode: newCode
+      },
+      conflicts
+    };
+  }
+  /**
+  * Detect conflicts between existing and updated schema fields
+  */
+  detectConflicts(existing, updated) {
+    const conflicts = [];
+    for (const updatedField of updated) {
+      const existingField = existing.find((f) => f.name === updatedField.name);
+      if (existingField) {
+        if (existingField.tsType !== updatedField.tsType) {
+          conflicts.push({
+            fieldName: updatedField.name,
+            type: "type_change",
+            message: `Type changed from "${existingField.tsType}" to "${updatedField.tsType}". Update your DTO accordingly.`,
+            oldValue: existingField.tsType,
+            newValue: updatedField.tsType
+          });
+        }
+        if (existingField.prop.required && !updatedField.prop.required) {
+          conflicts.push({
+            fieldName: updatedField.name,
+            type: "required_change",
+            message: "Field changed from required to optional. Consider updating your DTO.",
+            oldValue: "required",
+            newValue: "optional"
+          });
+        }
+      }
+    }
+    for (const existingField of existing) {
+      const stillExists = updated.find((f) => f.name === existingField.name);
+      if (!stillExists) {
+        conflicts.push({
+          fieldName: existingField.name,
+          type: "field_removed",
+          message: `Field "${existingField.name}" was removed. Update your DTO and service accordingly.`,
+          oldValue: existingField.name,
+          newValue: void 0
+        });
+      }
+    }
+    return conflicts;
+  }
+  /**
+  * Delete a schema and its entire module directory (controller, service, dto, etc.)
+  */
+  async deleteSchema(name) {
+    const modulesDir = this.getModulesDir();
+    const lowerName = name.toLowerCase();
+    const moduleDir = path__namespace.join(modulesDir, lowerName);
+    const schemaFile = path__namespace.join(moduleDir, `${lowerName}.schema.ts`);
+    const schemaFileAlt = path__namespace.join(moduleDir, "schemas", `${lowerName}.schema.ts`);
+    const filePath = fs__namespace.existsSync(schemaFile) ? schemaFile : fs__namespace.existsSync(schemaFileAlt) ? schemaFileAlt : null;
+    if (!filePath) {
+      return false;
+    }
+    if (fs__namespace.existsSync(moduleDir)) {
+      fs__namespace.rmSync(moduleDir, {
+        recursive: true
+      });
+      this.logger.log(`Module deleted: ${moduleDir}`);
+    }
+    return true;
+  }
+  /**
+  * Generate code preview without saving
+  */
+  previewCode(dto) {
+    const code = this.generateSchemaCode(dto);
+    const json = this.generateSchemaJSON(dto);
+    return {
+      code,
+      json
+    };
+  }
+  // ============================================================================
+  // Code Generation Methods
+  // ============================================================================
+  /**
+  * Generate module.ts code
+  */
+  generateModuleCode(name) {
+    const lowerName = name.toLowerCase();
+    return `import { MagnetModule } from '@magnet-cms/core'
+import { Module } from '@nestjs/common'
+import { ${name}Controller } from './${lowerName}.controller'
+import { ${name}Service } from './${lowerName}.service'
+import { ${name} } from './${lowerName}.schema'
+
+@Module({
+	imports: [MagnetModule.forFeature(${name})],
+	controllers: [${name}Controller],
+	providers: [${name}Service],
+})
+export class ${name}Module {}
+`;
+  }
+  /**
+  * Generate controller.ts code
+  */
+  generateControllerCode(name) {
+    const lowerName = name.toLowerCase();
+    return `import { Resolve } from '@magnet-cms/common'
+import {
+	Body,
+	Controller,
+	Delete,
+	Get,
+	Param,
+	Post,
+	Put,
+} from '@nestjs/common'
+import { Create${name}Dto } from './dto/create-${lowerName}.dto'
+import { ${name}Service } from './${lowerName}.service'
+import { ${name} } from './${lowerName}.schema'
+
+@Controller('${lowerName}')
+export class ${name}Controller {
+	constructor(private readonly ${lowerName}Service: ${name}Service) {}
+
+	@Post()
+	@Resolve(() => ${name})
+	create(@Body() dto: Create${name}Dto) {
+		return this.${lowerName}Service.create(dto)
+	}
+
+	@Get()
+	@Resolve(() => [${name}])
+	findAll() {
+		return this.${lowerName}Service.findAll()
+	}
+
+	@Get(':id')
+	@Resolve(() => ${name})
+	findOne(@Param('id') id: string) {
+		return this.${lowerName}Service.findOne(id)
+	}
+
+	@Put(':id')
+	@Resolve(() => Boolean)
+	update(@Param('id') id: string, @Body() dto: Create${name}Dto) {
+		return this.${lowerName}Service.update(id, dto)
+	}
+
+	@Delete(':id')
+	@Resolve(() => Boolean)
+	remove(@Param('id') id: string) {
+		return this.${lowerName}Service.remove(id)
+	}
+}
+`;
+  }
+  /**
+  * Generate service.ts code
+  */
+  generateServiceCode(name) {
+    const lowerName = name.toLowerCase();
+    return `import { InjectModel, Model } from '@magnet-cms/common'
+import { Injectable } from '@nestjs/common'
+import { Create${name}Dto } from './dto/create-${lowerName}.dto'
+import { ${name} } from './${lowerName}.schema'
+
+@Injectable()
+export class ${name}Service {
+	constructor(
+		@InjectModel(${name})
+		private model: Model<${name}>,
+	) {}
+
+	create(dto: Create${name}Dto) {
+		return this.model.create(dto)
+	}
+
+	findAll() {
+		return this.model.find()
+	}
+
+	findOne(id: string) {
+		return this.model.findById(id)
+	}
+
+	update(id: string, dto: Create${name}Dto) {
+		return this.model.update(id, dto)
+	}
+
+	remove(id: string) {
+		return this.model.delete(id)
+	}
+}
+`;
+  }
+  /**
+  * Generate DTO code
+  */
+  generateDtoCode(name, fields) {
+    const validatorImports = /* @__PURE__ */ new Set();
+    for (const field of fields) {
+      switch (field.tsType) {
+        case "string":
+          validatorImports.add("IsString");
+          break;
+        case "number":
+          validatorImports.add("IsNumber");
+          break;
+        case "boolean":
+          validatorImports.add("IsBoolean");
+          break;
+        case "Date":
+          validatorImports.add("IsDate");
+          break;
+      }
+      if (field.prop.required) {
+        validatorImports.add("IsNotEmpty");
+      } else {
+        validatorImports.add("IsOptional");
+      }
+      for (const v of field.validations) {
+        validatorImports.add(v.type);
+      }
+    }
+    const imports = Array.from(validatorImports).sort().join(",\n	");
+    const properties = fields.map((f) => this.generateDtoProperty(f)).join("\n\n");
+    return `import {
+	${imports},
+} from 'class-validator'
+
+export class Create${name}Dto {
+${properties}
+}
+`;
+  }
+  /**
+  * Generate a single DTO property with decorators
+  */
+  generateDtoProperty(field) {
+    const decorators = [];
+    const indent = "	";
+    switch (field.tsType) {
+      case "string":
+        decorators.push(`${indent}@IsString()`);
+        break;
+      case "number":
+        decorators.push(`${indent}@IsNumber()`);
+        break;
+      case "boolean":
+        decorators.push(`${indent}@IsBoolean()`);
+        break;
+      case "Date":
+        decorators.push(`${indent}@IsDate()`);
+        break;
+    }
+    if (field.prop.required) {
+      decorators.push(`${indent}@IsNotEmpty()`);
+    } else {
+      decorators.push(`${indent}@IsOptional()`);
+    }
+    for (const v of field.validations) {
+      if ([
+        "IsString",
+        "IsNumber",
+        "IsBoolean",
+        "IsDate",
+        "IsNotEmpty"
+      ].includes(v.type)) {
+        continue;
+      }
+      decorators.push(`${indent}@${this.formatValidator(v)}`);
+    }
+    const optional = field.prop.required ? "" : "?";
+    const declaration = `${indent}${field.name}${optional}: ${field.tsType}`;
+    return [
+      ...decorators,
+      declaration
+    ].join("\n");
+  }
+  /**
+  * Generate TypeScript schema code from DTO
+  */
+  generateSchemaCode(dto) {
+    if (!dto.name) {
+      return "// Enter a schema name to generate code";
+    }
+    const imports = this.generateImports(dto.fields);
+    const classDecorator = this.generateSchemaDecorator(dto.options);
+    const properties = dto.fields.map((field) => this.generateFieldCode(field)).join("\n\n");
+    return `${imports}
+
+${classDecorator}
+export class ${dto.name} {
+${properties}
+}
+`;
+  }
+  /**
+  * Generate import statements based on used features
+  */
+  generateImports(fields) {
+    const magnetImports = /* @__PURE__ */ new Set([
+      "Schema",
+      "Prop",
+      "UI"
+    ]);
+    const validatorImports = /* @__PURE__ */ new Set();
+    let needsTypeTransformer = false;
+    for (const field of fields) {
+      if (field.validations.length > 0) {
+        magnetImports.add("Validators");
+        for (const v of field.validations) {
+          validatorImports.add(v.type);
+        }
+      }
+      if (field.type === "date") {
+        needsTypeTransformer = true;
+      }
+    }
+    const lines = [];
+    lines.push(`import { ${Array.from(magnetImports).sort().join(", ")} } from '@magnet-cms/common'`);
+    if (needsTypeTransformer) {
+      lines.push(`import { Type } from 'class-transformer'`);
+    }
+    if (validatorImports.size > 0) {
+      lines.push(`import {
+	${Array.from(validatorImports).sort().join(",\n	")},
+} from 'class-validator'`);
+    }
+    return lines.join("\n");
+  }
+  /**
+  * Generate @Schema() decorator
+  */
+  generateSchemaDecorator(options) {
+    const opts = [];
+    if (options?.versioning !== void 0) {
+      opts.push(`versioning: ${options.versioning}`);
+    }
+    if (options?.i18n !== void 0) {
+      opts.push(`i18n: ${options.i18n}`);
+    }
+    if (opts.length === 0) {
+      return "@Schema()";
+    }
+    return `@Schema({ ${opts.join(", ")} })`;
+  }
+  /**
+  * Generate code for a single field
+  */
+  generateFieldCode(field) {
+    const decorators = [];
+    const indent = "	";
+    if (field.type === "date") {
+      decorators.push(`${indent}@Type(() => Date)`);
+    }
+    decorators.push(`${indent}@Prop(${this.generatePropOptions(field)})`);
+    if (field.validations.length > 0) {
+      const validators = field.validations.map((v) => this.formatValidator(v)).join(", ");
+      decorators.push(`${indent}@Validators(${validators})`);
+    }
+    decorators.push(`${indent}@UI(${this.generateUIOptions(field)})`);
+    const declaration = `${indent}${field.name}: ${field.tsType}`;
+    return [
+      ...decorators,
+      declaration
+    ].join("\n");
+  }
+  /**
+  * Generate @Prop() options object
+  */
+  generatePropOptions(field) {
+    const options = [];
+    if (field.prop.required) {
+      options.push("required: true");
+    }
+    if (field.prop.unique) {
+      options.push("unique: true");
+    }
+    if (field.prop.intl) {
+      options.push("intl: true");
+    }
+    if (field.prop.hidden) {
+      options.push("hidden: true");
+    }
+    if (field.prop.readonly) {
+      options.push("readonly: true");
+    }
+    if (field.prop.default !== void 0) {
+      options.push(`default: ${JSON.stringify(field.prop.default)}`);
+    }
+    if (options.length === 0) {
+      return "";
+    }
+    return `{ ${options.join(", ")} }`;
+  }
+  /**
+  * Generate @UI() options object
+  */
+  generateUIOptions(field) {
+    const options = [];
+    if (field.ui.tab) {
+      options.push(`tab: '${field.ui.tab}'`);
+    }
+    if (field.ui.side) {
+      options.push("side: true");
+    }
+    if (field.ui.type) {
+      options.push(`type: '${field.ui.type}'`);
+    }
+    if (field.ui.label && field.ui.label !== field.displayName) {
+      options.push(`label: '${this.escapeString(field.ui.label)}'`);
+    }
+    if (field.ui.description) {
+      options.push(`description: '${this.escapeString(field.ui.description)}'`);
+    }
+    if (field.ui.placeholder) {
+      options.push(`placeholder: '${this.escapeString(field.ui.placeholder)}'`);
+    }
+    if (field.ui.row) {
+      options.push("row: true");
+    }
+    if (field.ui.options && field.ui.options.length > 0) {
+      const optionsStr = field.ui.options.map((o) => `{ key: '${this.escapeString(o.key)}', value: '${this.escapeString(o.value)}' }`).join(", ");
+      options.push(`options: [${optionsStr}]`);
+    }
+    if (options.length === 0) {
+      return "{}";
+    }
+    return `{ ${options.join(", ")} }`;
+  }
+  /**
+  * Format a validator call
+  */
+  formatValidator(rule) {
+    if (!rule.constraints || rule.constraints.length === 0) {
+      return `${rule.type}()`;
+    }
+    const args = rule.constraints.map((c) => {
+      if (typeof c === "string") {
+        if (rule.type === "Matches") {
+          return c.startsWith("/") ? c : `/${c}/`;
+        }
+        return `'${this.escapeString(String(c))}'`;
+      }
+      return String(c);
+    }).join(", ");
+    return `${rule.type}(${args})`;
+  }
+  /**
+  * Escape string for use in generated code
+  */
+  escapeString(str) {
+    return str.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+  }
+  /**
+  * Generate JSON representation of the schema
+  */
+  generateSchemaJSON(dto) {
+    return {
+      name: dto.name,
+      options: {
+        versioning: dto.options?.versioning ?? true,
+        i18n: dto.options?.i18n ?? true
+      },
+      properties: dto.fields.map((field) => ({
+        name: field.name,
+        displayName: field.displayName,
+        type: field.type,
+        tsType: field.tsType,
+        required: field.prop.required,
+        unique: field.prop.unique,
+        intl: field.prop.intl,
+        ui: field.ui,
+        validations: field.validations,
+        ...field.relationConfig && {
+          relationConfig: field.relationConfig
+        }
+      }))
+    };
+  }
+  /**
+  * Parse a schema file content to extract metadata
+  */
+  parseSchemaFile(content) {
+    try {
+      const classMatch = content.match(/export\s+class\s+(\w+)/);
+      if (!classMatch?.[1]) return null;
+      const name = classMatch[1];
+      const schemaMatch = content.match(/@Schema\(\{([^}]*)\}\)/);
+      const options = {};
+      if (schemaMatch?.[1]) {
+        const optionsStr = schemaMatch[1];
+        if (optionsStr.includes("versioning: true")) options.versioning = true;
+        if (optionsStr.includes("versioning: false")) options.versioning = false;
+        if (optionsStr.includes("i18n: true")) options.i18n = true;
+        if (optionsStr.includes("i18n: false")) options.i18n = false;
+      }
+      const fields = [];
+      const fieldRegex = /@Prop\(([^)]*)\)[^@]*@UI\(([^)]*)\)[^:]*(\w+):\s*(\w+)/g;
+      let fieldMatch = fieldRegex.exec(content);
+      while (fieldMatch !== null) {
+        const propStr = fieldMatch[1];
+        const uiStr = fieldMatch[2];
+        const fieldName = fieldMatch[3];
+        const tsType = fieldMatch[4];
+        if (propStr !== void 0 && uiStr && fieldName && tsType) {
+          fields.push({
+            name: fieldName,
+            displayName: fieldName,
+            type: this.inferFieldType(tsType, uiStr),
+            tsType,
+            prop: {
+              required: propStr.includes("required: true"),
+              unique: propStr.includes("unique: true"),
+              intl: propStr.includes("intl: true")
+            },
+            ui: this.parseUIOptions(uiStr),
+            validations: []
+          });
+        }
+        fieldMatch = fieldRegex.exec(content);
+      }
+      return {
+        name,
+        options,
+        fields
+      };
+    } catch (error) {
+      this.logger.error("Failed to parse schema file", error);
+      return null;
+    }
+  }
+  /**
+  * Infer field type from TypeScript type and UI options
+  */
+  inferFieldType(tsType, uiStr) {
+    if (uiStr.includes("type: 'switch'") || uiStr.includes("type: 'checkbox'")) return "boolean";
+    if (uiStr.includes("type: 'date'")) return "date";
+    if (uiStr.includes("type: 'number'")) return "number";
+    if (uiStr.includes("type: 'select'") || uiStr.includes("type: 'radio'")) return "select";
+    if (uiStr.includes("type: 'relationship'")) return "relation";
+    const lowerType = tsType.toLowerCase();
+    if (lowerType === "number") return "number";
+    if (lowerType === "boolean") return "boolean";
+    if (lowerType === "date") return "date";
+    return "text";
+  }
+  /**
+  * Parse UI options from string
+  */
+  parseUIOptions(uiStr) {
+    const ui = {};
+    const tabMatch = uiStr.match(/tab:\s*'([^']*)'/);
+    if (tabMatch) ui.tab = tabMatch[1];
+    const typeMatch = uiStr.match(/type:\s*'([^']*)'/);
+    if (typeMatch) ui.type = typeMatch[1];
+    const labelMatch = uiStr.match(/label:\s*'([^']*)'/);
+    if (labelMatch) ui.label = labelMatch[1];
+    const descMatch = uiStr.match(/description:\s*'([^']*)'/);
+    if (descMatch) ui.description = descMatch[1];
+    if (uiStr.includes("side: true")) ui.side = true;
+    if (uiStr.includes("row: true")) ui.row = true;
+    return ui;
+  }
+};
+PlaygroundService = _ts_decorate([
+  common.Injectable(),
+  _ts_param(0, common.Optional()),
+  _ts_param(0, common.Inject(common$1.MagnetModuleOptions)),
+  _ts_param(1, common.Optional()),
+  _ts_param(1, core.InjectPluginOptions("playground")),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof common$1.MagnetModuleOptions === "undefined" ? Object : common$1.MagnetModuleOptions,
+    typeof PlaygroundPluginOptions === "undefined" ? Object : PlaygroundPluginOptions
+  ])
+], PlaygroundService);
+
+// src/backend/playground.controller.ts
+function _ts_decorate2(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
+function _ts_metadata2(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata2, "_ts_metadata");
+function _ts_param2(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param2, "_ts_param");
+var PlaygroundController = class {
+  static {
+    __name(this, "PlaygroundController");
+  }
+  playgroundService;
+  constructor(playgroundService) {
+    this.playgroundService = playgroundService;
+  }
+  /**
+  * List all schemas
+  * GET /playground/schemas
+  */
+  async listSchemas() {
+    try {
+      return await this.playgroundService.listSchemas();
+    } catch (error) {
+      throw new common.HttpException(error instanceof Error ? error.message : "Failed to list schemas", common.HttpStatus.INTERNAL_SERVER_ERROR);
+    }
+  }
+  /**
+  * Get a schema by name
+  * GET /playground/schemas/:name
+  */
+  async getSchema(name) {
+    try {
+      const schema = await this.playgroundService.getSchema(name);
+      if (!schema) {
+        throw new common.HttpException("Schema not found", common.HttpStatus.NOT_FOUND);
+      }
+      return schema;
+    } catch (error) {
+      if (error instanceof common.HttpException) throw error;
+      throw new common.HttpException(error instanceof Error ? error.message : "Failed to get schema", common.HttpStatus.INTERNAL_SERVER_ERROR);
+    }
+  }
+  /**
+  * Create a new module with schema, controller, service, and DTO
+  * POST /playground/schemas
+  */
+  async createSchema(body) {
+    try {
+      if (!body.name || !/^[A-Z][A-Za-z0-9]*$/.test(body.name)) {
+        throw new common.HttpException("Invalid schema name. Must start with uppercase letter and contain only alphanumeric characters.", common.HttpStatus.BAD_REQUEST);
+      }
+      if (this.playgroundService.schemaExists(body.name)) {
+        throw new common.HttpException("Module with this name already exists. Use PUT to update the schema.", common.HttpStatus.CONFLICT);
+      }
+      return await this.playgroundService.createModule(body);
+    } catch (error) {
+      if (error instanceof common.HttpException) throw error;
+      throw new common.HttpException(error instanceof Error ? error.message : "Failed to create module", common.HttpStatus.INTERNAL_SERVER_ERROR);
+    }
+  }
+  /**
+  * Update an existing schema (only the schema file, not the whole module)
+  * Returns conflicts if field types have changed
+  * PUT /playground/schemas/:name
+  */
+  async updateSchema(name, body) {
+    try {
+      if (!body.name || !/^[A-Z][A-Za-z0-9]*$/.test(body.name)) {
+        throw new common.HttpException("Invalid schema name. Must start with uppercase letter and contain only alphanumeric characters.", common.HttpStatus.BAD_REQUEST);
+      }
+      if (!this.playgroundService.schemaExists(name)) {
+        throw new common.HttpException("Schema not found. Use POST to create a new module.", common.HttpStatus.NOT_FOUND);
+      }
+      if (body.name.toLowerCase() !== name.toLowerCase()) {
+        throw new common.HttpException("Renaming schemas is not supported. Create a new module instead.", common.HttpStatus.BAD_REQUEST);
+      }
+      const result = await this.playgroundService.updateSchema(name, body);
+      return {
+        ...result.detail,
+        conflicts: result.conflicts
+      };
+    } catch (error) {
+      if (error instanceof common.HttpException) throw error;
+      throw new common.HttpException(error instanceof Error ? error.message : "Failed to update schema", common.HttpStatus.INTERNAL_SERVER_ERROR);
+    }
+  }
+  /**
+  * Delete a schema
+  * DELETE /playground/schemas/:name
+  */
+  async deleteSchema(name) {
+    try {
+      const deleted = await this.playgroundService.deleteSchema(name);
+      if (!deleted) {
+        throw new common.HttpException("Schema not found", common.HttpStatus.NOT_FOUND);
+      }
+      return {
+        success: true
+      };
+    } catch (error) {
+      if (error instanceof common.HttpException) throw error;
+      throw new common.HttpException(error instanceof Error ? error.message : "Failed to delete schema", common.HttpStatus.INTERNAL_SERVER_ERROR);
+    }
+  }
+  /**
+  * Generate code preview without saving
+  * POST /playground/preview
+  */
+  previewCode(body) {
+    try {
+      return this.playgroundService.previewCode(body);
+    } catch (error) {
+      throw new common.HttpException(error instanceof Error ? error.message : "Failed to generate preview", common.HttpStatus.INTERNAL_SERVER_ERROR);
+    }
+  }
+};
+_ts_decorate2([
+  common.Get("schemas"),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", []),
+  _ts_metadata2("design:returntype", Promise)
+], PlaygroundController.prototype, "listSchemas", null);
+_ts_decorate2([
+  common.Get("schemas/:name"),
+  _ts_param2(0, common.Param("name")),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    String
+  ]),
+  _ts_metadata2("design:returntype", Promise)
+], PlaygroundController.prototype, "getSchema", null);
+_ts_decorate2([
+  common.Post("schemas"),
+  _ts_param2(0, common.Body()),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof CreateSchemaDto === "undefined" ? Object : CreateSchemaDto
+  ]),
+  _ts_metadata2("design:returntype", Promise)
+], PlaygroundController.prototype, "createSchema", null);
+_ts_decorate2([
+  common.Put("schemas/:name"),
+  _ts_param2(0, common.Param("name")),
+  _ts_param2(1, common.Body()),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    String,
+    typeof CreateSchemaDto === "undefined" ? Object : CreateSchemaDto
+  ]),
+  _ts_metadata2("design:returntype", Promise)
+], PlaygroundController.prototype, "updateSchema", null);
+_ts_decorate2([
+  common.Delete("schemas/:name"),
+  _ts_param2(0, common.Param("name")),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    String
+  ]),
+  _ts_metadata2("design:returntype", Promise)
+], PlaygroundController.prototype, "deleteSchema", null);
+_ts_decorate2([
+  common.Post("preview"),
+  _ts_param2(0, common.Body()),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof CreateSchemaDto === "undefined" ? Object : CreateSchemaDto
+  ]),
+  _ts_metadata2("design:returntype", void 0)
+], PlaygroundController.prototype, "previewCode", null);
+PlaygroundController = _ts_decorate2([
+  common.Controller("playground"),
+  core.RestrictedRoute(),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof PlaygroundService === "undefined" ? Object : PlaygroundService
+  ])
+], PlaygroundController);
+
+// src/backend/playground.module.ts
+function _ts_decorate3(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate3, "_ts_decorate");
+exports.PlaygroundModule = class PlaygroundModule {
+  static {
+    __name(this, "PlaygroundModule");
+  }
+};
+exports.PlaygroundModule = _ts_decorate3([
+  common.Module({
+    controllers: [
+      PlaygroundController
+    ],
+    providers: [
+      PlaygroundService
+    ],
+    exports: [
+      PlaygroundService
+    ]
+  })
+], exports.PlaygroundModule);