@postxl/schema 1.5.0 → 1.6.0

package/dist/extract-inline-enums.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Extracts inline enum definitions from model fields and promotes them to top-level enums.
+ *
+ * When a field's `type` is an object or array (instead of a string), it is treated as an
+ * inline enum definition. The enum members are extracted, a name is generated as
+ * `{ModelName}{PascalCase(fieldName)}`, and the field's `type` is replaced with that name.
+ *
+ * Inline enum format examples:
+ *
+ * Object format:
+ *   "type": { "Draft": "description", "Published": "description" }
+ *
+ * Array format:
+ *   "type": ["Draft", { "value": "Published", "description": "..." }]
+ *
+ * The field's `description` is copied to the enum and also kept on the field.
+ * The enum's database schema is derived from the parent model's `schema` property.
+ */
+export declare function extractInlineEnumDefinitions(input: Record<string, unknown>): Record<string, unknown>;

package/dist/extract-inline-enums.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractInlineEnumDefinitions = extractInlineEnumDefinitions;
+const utils_1 = require("@postxl/utils");
+/**
+ * Extracts inline enum definitions from model fields and promotes them to top-level enums.
+ *
+ * When a field's `type` is an object or array (instead of a string), it is treated as an
+ * inline enum definition. The enum members are extracted, a name is generated as
+ * `{ModelName}{PascalCase(fieldName)}`, and the field's `type` is replaced with that name.
+ *
+ * Inline enum format examples:
+ *
+ * Object format:
+ *   "type": { "Draft": "description", "Published": "description" }
+ *
+ * Array format:
+ *   "type": ["Draft", { "value": "Published", "description": "..." }]
+ *
+ * The field's `description` is copied to the enum and also kept on the field.
+ * The enum's database schema is derived from the parent model's `schema` property.
+ */
+function extractInlineEnumDefinitions(input) {
+    const models = input.models;
+    if (!models || typeof models !== 'object') {
+        return input;
+    }
+    const extractedEnums = [];
+    const existingEnumNames = getExistingEnumNames(input.enums);
+    const generatedEnumNames = new Set();
+    let modelsModified = false;
+    const createProcessField = (modelSchema) => (modelName, fieldName, fieldDef) => {
+        const type = fieldDef.type;
+        if (type === undefined || type === null || typeof type === 'string') {
+            return undefined;
+        }
+        // type is an object or array — this is an inline enum definition
+        const enumName = modelName + (0, utils_1.toPascalCase)(fieldName);
+        if (existingEnumNames.has(enumName)) {
+            throw new Error(`Inline enum "${enumName}" generated from field "${modelName}.${fieldName}" conflicts with an existing top-level enum of the same name. ` +
+                `Rename the field or define the enum in the top-level "enums" section instead.`);
+        }
+        if (generatedEnumNames.has(enumName)) {
+            throw new Error(`Inline enum "${enumName}" generated from field "${modelName}.${fieldName}" conflicts with another inline enum of the same name. ` +
+                `Rename one of the fields to avoid the collision.`);
+        }
+        generatedEnumNames.add(enumName);
+        const enumDef = {
+            name: enumName,
+            members: type,
+        };
+        // Copy description to the enum (it stays on the field as well)
+        if (fieldDef.description !== undefined) {
+            enumDef.description = fieldDef.description;
+        }
+        // Use the parent model's schema for the enum
+        if (modelSchema !== undefined) {
+            enumDef.schema = modelSchema;
+        }
+        extractedEnums.push(enumDef);
+        // Build the modified field: replace type with enum name, remove schema (not a field property)
+        const modifiedField = {};
+        for (const [key, value] of Object.entries(fieldDef)) {
+            if (key === 'type') {
+                modifiedField.type = enumName;
+            }
+            else if (key === 'schema') {
+                // schema is not a field property — skip it
+                continue;
+            }
+            else {
+                modifiedField[key] = value;
+            }
+        }
+        return modifiedField;
+    };
+    let newModels = models;
+    if (Array.isArray(models)) {
+        const modifiedModels = models.map((model) => {
+            if (!model || typeof model !== 'object' || !model.name) {
+                return model;
+            }
+            const modelSchema = model.schema;
+            const newFields = processFields(model.name, model.fields, createProcessField(modelSchema));
+            if (newFields === undefined) {
+                return model;
+            }
+            modelsModified = true;
+            return { ...model, fields: newFields };
+        });
+        if (modelsModified) {
+            newModels = modifiedModels;
+        }
+    }
+    else {
+        const modifiedModels = {};
+        for (const [modelName, modelDef] of Object.entries(models)) {
+            if (!modelDef || typeof modelDef !== 'object') {
+                modifiedModels[modelName] = modelDef;
+                continue;
+            }
+            const model = modelDef;
+            const modelSchema = model.schema;
+            const newFields = processFields(modelName, model.fields, createProcessField(modelSchema));
+            if (newFields === undefined) {
+                modifiedModels[modelName] = modelDef;
+            }
+            else {
+                modelsModified = true;
+                modifiedModels[modelName] = { ...model, fields: newFields };
+            }
+        }
+        if (modelsModified) {
+            newModels = modifiedModels;
+        }
+    }
+    if (extractedEnums.length === 0) {
+        return input;
+    }
+    return {
+        ...input,
+        models: newModels,
+        enums: mergeEnums(input.enums, extractedEnums),
+    };
+}
+function processFields(modelName, fields, processField) {
+    if (!fields || typeof fields !== 'object') {
+        return undefined;
+    }
+    let anyModified = false;
+    if (Array.isArray(fields)) {
+        const modifiedFields = fields.map((field) => {
+            if (!field || typeof field !== 'object' || !field.name) {
+                return field;
+            }
+            const result = processField(modelName, field.name, field);
+            if (result === undefined) {
+                return field;
+            }
+            anyModified = true;
+            return result;
+        });
+        return anyModified ? modifiedFields : undefined;
+    }
+    const modifiedFields = {};
+    for (const [fieldName, fieldDef] of Object.entries(fields)) {
+        if (!fieldDef || typeof fieldDef !== 'object') {
+            modifiedFields[fieldName] = fieldDef;
+            continue;
+        }
+        const result = processField(modelName, fieldName, fieldDef);
+        if (result === undefined) {
+            modifiedFields[fieldName] = fieldDef;
+        }
+        else {
+            anyModified = true;
+            modifiedFields[fieldName] = result;
+        }
+    }
+    return anyModified ? modifiedFields : undefined;
+}
+function getExistingEnumNames(enums) {
+    const names = new Set();
+    if (Array.isArray(enums)) {
+        for (const e of enums) {
+            if (e && typeof e === 'object' && typeof e.name === 'string') {
+                names.add(e.name);
+            }
+        }
+    }
+    else if (enums && typeof enums === 'object') {
+        for (const key of Object.keys(enums)) {
+            names.add(key);
+        }
+    }
+    return names;
+}
+function mergeEnums(existing, extracted) {
+    if (existing === undefined || existing === null) {
+        return extracted;
+    }
+    if (Array.isArray(existing)) {
+        return [...existing, ...extracted];
+    }
+    if (typeof existing === 'object') {
+        // Existing enums are in object format — convert extracted enums to object format and merge
+        const result = { ...existing };
+        for (const enumDef of extracted) {
+            const { name, ...rest } = enumDef;
+            result[name] = rest;
+        }
+        return result;
+    }
+    return existing;
+}

package/dist/project-schema/project-schema.json-decoder.js

@@ -37,6 +37,7 @@ exports.zProjectSchemaJSON = exports.zSchemaName = void 0;
 const zod_1 = require("zod");
 const utils_1 = require("@postxl/utils");
 const Enum = __importStar(require("../enum"));
+const extract_inline_enums_1 = require("../extract-inline-enums");
 const Model = __importStar(require("../model"));
 const normalize_named_collection_1 = require("../normalize-named-collection");
 exports.zSchemaName = zod_1.z
@@ -54,13 +55,18 @@ exports.zProjectSchemaJSON = zod_1.z
     .preprocess((input) => {
     if (typeof input === 'object' && input !== null) {
         const original = input;
+        // Extract inline enum definitions from model fields before normalization.
+        // This converts inline enum types (objects/arrays in field.type) to top-level enums
+        // and replaces the field type with the generated enum name.
+        const withExtractedEnums = (0, extract_inline_enums_1.extractInlineEnumDefinitions)(original);
         return {
-            ...original,
-            models: (0, normalize_named_collection_1.normalizeNamedCollection)(original.models),
-            enums: (0, normalize_named_collection_1.normalizeNamedCollection)(original.enums),
+            ...withExtractedEnums,
+            models: (0, normalize_named_collection_1.normalizeNamedCollection)(withExtractedEnums.models),
+            enums: (0, normalize_named_collection_1.normalizeNamedCollection)(withExtractedEnums.enums),
             // We omit models from the source fields as we keep the original input in model.source
-            // as part of the model schema.
-            source: (0, utils_1.omit)(original, 'models'),
+            // as part of the model schema. We use the post-extraction data so that source.enums
+            // reflects the extracted inline enums.
+            source: (0, utils_1.omit)(withExtractedEnums, 'models'),
         };
     }
     return input;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@postxl/schema",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "Decoders for PXL Schema definitions and validation for PXL code generation framework",
   "main": "./dist/index.js",
   "module": "./dist/index.js",