@magnet-cms/plugin-playground 2.0.0

package/dist/index.cjs

@@ -0,0 +1,1135 @@
+'use strict';
+
+var fs = require('fs');
+var path = require('path');
+var common$1 = require('@magnet-cms/common');
+var core = require('@magnet-cms/core');
+var common = require('@nestjs/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 __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+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;
+}
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+var PlaygroundService;
+var init_playground_service = __esm({
+  "src/backend/playground.service.ts"() {
+    __name(_ts_decorate, "_ts_decorate");
+    __name(_ts_metadata, "_ts_metadata");
+    __name(_ts_param, "_ts_param");
+    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);
+  }
+});
+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;
+}
+function _ts_metadata2(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param2(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+var PlaygroundController;
+var init_playground_controller = __esm({
+  "src/backend/playground.controller.ts"() {
+    init_playground_service();
+    __name(_ts_decorate2, "_ts_decorate");
+    __name(_ts_metadata2, "_ts_metadata");
+    __name(_ts_param2, "_ts_param");
+    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
+var playground_module_exports = {};
+__export(playground_module_exports, {
+  PlaygroundModule: () => exports.PlaygroundModule
+});
+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;
+}
+exports.PlaygroundModule = void 0;
+var init_playground_module = __esm({
+  "src/backend/playground.module.ts"() {
+    init_playground_controller();
+    init_playground_service();
+    __name(_ts_decorate3, "_ts_decorate");
+    exports.PlaygroundModule = class {
+      static {
+        __name(this, "PlaygroundModule");
+      }
+    };
+    exports.PlaygroundModule = _ts_decorate3([
+      common.Module({
+        controllers: [
+          PlaygroundController
+        ],
+        providers: [
+          PlaygroundService
+        ],
+        exports: [
+          PlaygroundService
+        ]
+      })
+    ], exports.PlaygroundModule);
+  }
+});
+function _ts_decorate4(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_decorate4, "_ts_decorate");
+exports.PlaygroundPlugin = class _PlaygroundPlugin {
+  static {
+    __name(this, "PlaygroundPlugin");
+  }
+  /**
+  * Create a configured plugin provider for MagnetModule.forRoot().
+  *
+  * @example
+  * ```typescript
+  * MagnetModule.forRoot([
+  *   PlaygroundPlugin.forRoot(),
+  * ])
+  * ```
+  */
+  static forRoot(config) {
+    return {
+      type: "plugin",
+      plugin: _PlaygroundPlugin,
+      options: config,
+      envVars: []
+    };
+  }
+};
+exports.PlaygroundPlugin = _ts_decorate4([
+  core.Plugin({
+    name: "playground",
+    description: "Playground: visual schema builder and code generator for Magnet CMS",
+    version: "1.0.0",
+    module: /* @__PURE__ */ __name(() => (init_playground_module(), __toCommonJS(playground_module_exports)).PlaygroundModule, "module"),
+    frontend: {
+      routes: [
+        {
+          path: "playground",
+          componentId: "PlaygroundIndex",
+          requiresAuth: true,
+          children: [
+            {
+              path: "",
+              componentId: "PlaygroundIndex"
+            },
+            {
+              path: "new",
+              componentId: "PlaygroundEditor"
+            },
+            {
+              path: ":schemaName",
+              componentId: "PlaygroundEditor"
+            }
+          ]
+        }
+      ],
+      sidebar: [
+        {
+          id: "playground",
+          title: "Playground",
+          url: "/playground",
+          icon: "Boxes",
+          order: 20
+        }
+      ]
+    }
+  })
+], exports.PlaygroundPlugin);
+
+// src/backend/index.ts
+init_playground_module();