@postxl/schema 0.0.2

package/dist/project-schema/project-schema.transformer.js

@@ -0,0 +1,444 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zProjectSchema = void 0;
+exports.transformProjectSchemaJSON = transformProjectSchemaJSON;
+const zod_1 = require("zod");
+const utils_1 = require("@postxl/utils");
+const Enum = __importStar(require("../enum"));
+const Field = __importStar(require("../field"));
+const Model = __importStar(require("../model"));
+const Branded = __importStar(require("./project-schema.brands"));
+const project_schema_defaults_1 = require("./project-schema.defaults");
+const project_schema_json_decoder_1 = require("./project-schema.json-decoder");
+function transformProjectSchemaJSON(input, ctx) {
+    const result = (0, utils_1.pipeZodTransformers)(input, ctx, [
+        convertRecordsToMaps,
+        addDefaults,
+        brandProjectSchema,
+        combineAndTransformEnums,
+        combineModels,
+        decodeFields,
+        transformModels,
+        advancedValidations,
+    ]);
+    return result;
+}
+/**
+ * Zod decoder that converts JSON (see `ProjectSchemaJSON`) to a `ProjectSchema`
+ */
+exports.zProjectSchema = project_schema_json_decoder_1.zProjectSchemaJSON.transform(transformProjectSchemaJSON);
+function convertRecordsToMaps(input) {
+    return {
+        ...input,
+        models: new Map(Object.entries(input.models ?? {})),
+        enums: new Map(Object.entries(input.enums ?? {})),
+    };
+}
+function addDefaults(input) {
+    const schemas = input.schemas ?? [project_schema_defaults_1.databaseSchemaNameData, project_schema_defaults_1.databaseSchemaNameConfig];
+    const defaultSchema = getDefaultSchema(input.schemas, input.defaultSchema);
+    return {
+        name: input.name,
+        slug: input.slug,
+        description: input.description ?? '',
+        projectType: input.projectType ?? { kind: 'workspace', projectDirectory: input.slug },
+        version: input.version ?? '0.0.1',
+        schemas,
+        defaultSchema,
+        systemUser: {
+            ...project_schema_defaults_1.defaultSystemUser,
+            ...input.systemUser,
+        },
+        standardModels: input.standardModels ?? Array.from(Object.values(Model.defaultModelNames)),
+        models: input.models ?? new Map(),
+        standardEnums: input.standardEnums ?? Array.from(Object.values(Enum.defaultEnumNames)),
+        enums: input.enums ?? new Map(),
+        source: input.source,
+    };
+}
+function getDefaultSchema(schemas, defaultSchema) {
+    if (defaultSchema !== undefined) {
+        return defaultSchema;
+    }
+    if (schemas === undefined) {
+        return project_schema_defaults_1.databaseSchemaNameData;
+    }
+    if (schemas.length === 0) {
+        return project_schema_defaults_1.databaseSchemaNameData;
+    }
+    return schemas[0];
+}
+function brandProjectSchema({ name, slug, schemas, defaultSchema, standardModels, standardEnums, ...input }) {
+    return {
+        ...input,
+        name: Branded.toProjectSchemaName(name),
+        slug: Branded.toProjectSlug(slug),
+        databaseSchemas: schemas.map((s) => Branded.toDatabaseSchemaName(s)),
+        defaultDatabaseSchema: Branded.toDatabaseSchemaName(defaultSchema),
+        standardModels: standardModels.map((s) => Model.toModelName(s)),
+        standardEnums: standardEnums.map((s) => Enum.toEnumName(s)),
+    };
+}
+/**
+ * Combines provided input enums with standard enums and transforms them to dictionary of fully typed enums
+ */
+function combineAndTransformEnums({ enums, standardEnums, ...projectSchema }, ctx) {
+    // All standard enums use the config database schema by default. However, if the project schema does not specify
+    // a config database schema, we use the default database schema instead.
+    const databaseSchema = projectSchema.databaseSchemas.find((s) => s === project_schema_defaults_1.databaseSchemaNameConfig) ?? projectSchema.defaultDatabaseSchema;
+    const standardEnumsSelected = [];
+    for (const standardEnum of standardEnums) {
+        if ([...enums.values()].find((e) => e.name === standardEnum)) {
+            // A more specific enum has been defined, we skip the standard enum
+            continue;
+        }
+        const standardEnumInput = Enum.defaultEnumsJson[standardEnum];
+        if (!standardEnumInput) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                message: `Standard enum ${standardEnum} is not defined!`,
+            });
+            return zod_1.z.NEVER;
+        }
+        const e = { ...standardEnumInput, schema: databaseSchema };
+        standardEnumsSelected.push(e);
+    }
+    const enumsMap = new Map();
+    const enumNames = [];
+    for (const inputEnum of [...standardEnumsSelected, ...enums.values()]) {
+        const enumEnriched = Enum.enumTransformer(inputEnum, ctx);
+        const enumBranded = {
+            ...enumEnriched,
+            databaseSchema: enumEnriched.databaseSchema ?? projectSchema.defaultDatabaseSchema,
+        };
+        if (enumsMap.get(enumBranded.name) !== undefined) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                message: `Enum ${inputEnum.name} is defined  multiple times in project ${projectSchema.name}!`,
+            });
+            return zod_1.z.NEVER;
+        }
+        enumsMap.set(enumBranded.name, enumBranded);
+        enumNames.push(enumBranded.name);
+    }
+    return {
+        ...projectSchema,
+        enums: enumsMap,
+        enumNames,
+    };
+}
+/**
+ * Combines provided input models with standard models. The standard models are placed first.
+ */
+function combineModels({ models, standardModels, ...projectSchema }, ctx) {
+    const modelsInput = new Map();
+    for (const inputModel of models.values()) {
+        if (modelsInput.get(inputModel.name) !== undefined) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                message: `Model ${inputModel.name} is defined  multiple times in project ${projectSchema.name}!`,
+            });
+            return zod_1.z.NEVER;
+        }
+        modelsInput.set(inputModel.name, inputModel);
+    }
+    const standardModelsToInclude = [];
+    // All standard enums use the config database schema by default. However, if the project schema does not specify
+    // a config database schema, we use the default database schema instead.
+    const databaseSchema = projectSchema.databaseSchemas.find((s) => s === project_schema_defaults_1.databaseSchemaNameConfig) ?? projectSchema.defaultDatabaseSchema;
+    for (const standardModel of standardModels) {
+        if (modelsInput.get(standardModel) !== undefined) {
+            continue;
+        }
+        const standardModelInput = Model.defaultModelsJson[standardModel];
+        if (!standardModelInput) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                message: `Standard model ${standardModel} is not defined!`,
+            });
+            return zod_1.z.NEVER;
+        }
+        const m = { ...standardModelInput, schema: databaseSchema, source: standardModelInput };
+        standardModelsToInclude.push(m);
+    }
+    const modelsArray = [];
+    const modelNames = [];
+    const modelsMap = new Map();
+    for (const modelInput of [...standardModelsToInclude, ...models.values()]) {
+        const model = Model.modelJSONTransformer(modelInput, ctx);
+        modelsArray.push(model);
+        modelNames.push(model.name);
+        modelsMap.set(model.name, model);
+    }
+    return {
+        ...projectSchema,
+        /**
+         * Record of model names to model
+         */
+        models: modelsMap,
+        /**
+         * We also provide an array of models for quick iterations
+         */
+        modelsArray,
+        modelNames,
+    };
+}
+/**
+ * Decode fields for each model
+ */
+function decodeFields({ modelsArray, ...projectSchema }, ctx) {
+    const modelsWithFields = new Map();
+    const fieldDecoder = Field.createFieldJSONDecoder(projectSchema);
+    for (const inputModel of modelsArray) {
+        const fields = new Map();
+        const fieldsArray = [];
+        for (const fieldName of inputModel.fieldNames) {
+            const fieldDecoded = fieldDecoder.safeParse(inputModel.fields[fieldName]);
+            if (!fieldDecoded.success) {
+                ctx.addIssue({
+                    code: zod_1.z.ZodIssueCode.custom,
+                    message: `Error decoding field ${inputModel.name}.${fieldName}: ${fieldDecoded.error.message}`,
+                });
+                return zod_1.z.NEVER;
+            }
+            const field = fieldDecoded.data;
+            fields.set(field.name, field);
+            fieldsArray.push(field);
+        }
+        const modelWithFields = {
+            ...inputModel,
+            fields,
+            fieldsArray,
+        };
+        modelsWithFields.set(inputModel.name, modelWithFields);
+    }
+    return {
+        ...projectSchema,
+        models: modelsWithFields,
+    };
+}
+/**
+ * Transforms the combined models to the final model type
+ */
+function transformModels(projectSchema, ctx) {
+    const models = new Map();
+    for (const inputModelName of projectSchema.modelNames) {
+        const model = transformModel(projectSchema.models.get(inputModelName), projectSchema, ctx);
+        models.set(model.name, model);
+    }
+    return {
+        ...projectSchema,
+        models,
+    };
+}
+function transformModel(model, projectSchema, ctx) {
+    const fields = transformFields(model, projectSchema, ctx);
+    validateFields(fields, ctx);
+    const idField = extractIdField(fields, model, ctx);
+    const defaultField = extractDefaultField(model, fields, ctx);
+    const labelField = extractLabelField(model, fields, ctx);
+    const { defaultFieldName, labelFieldName, ...remainingModel } = model;
+    return {
+        ...remainingModel,
+        databaseSchema: model.schema ?? projectSchema.defaultDatabaseSchema,
+        fields,
+        defaultField,
+        labelField,
+        idField,
+    };
+}
+function transformFields(model, projectSchema, ctx) {
+    const fields = new Map();
+    for (const inputFieldName of model.fieldNames) {
+        const field = Field.fieldTransformer(model.fields.get(inputFieldName), model, projectSchema, ctx);
+        fields.set(field.name, field);
+    }
+    return fields;
+}
+function validateFields(fields, ctx) {
+    const backReferences = new Map();
+    for (const field of fields.values()) {
+        if (field.kind !== 'relation') {
+            continue;
+        }
+        const backReference = backReferences.get(field.referencedModelName) ?? new Set();
+        if (backReference.has(field.prismaRelationFieldName)) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                message: `Model ${field.modelName} references ${field.referencedModelName} multiple times (reference name ${field.prismaRelationFieldName}). Use 'prismaRelationFieldName' property to separate them!`,
+            });
+            return;
+        }
+        backReference.add(field.prismaRelationFieldName);
+        backReferences.set(field.referencedModelName, backReference);
+    }
+}
+function advancedValidations(projectSchema, ctx) {
+    validateDatabaseSchemasMatchModelsAndEnums(projectSchema, ctx);
+    return projectSchema;
+}
+function validateDatabaseSchemasMatchModelsAndEnums(projectSchema, ctx) {
+    const schemasUsed = new Set();
+    const schemasProvided = new Set(projectSchema.databaseSchemas);
+    validateModelSchemas(projectSchema.models, schemasProvided, schemasUsed, ctx);
+    validateEnumSchemas(projectSchema.enums, schemasProvided, schemasUsed, ctx);
+    validateProjectSchemas(projectSchema.databaseSchemas, schemasUsed, projectSchema.defaultDatabaseSchema, ctx);
+    return projectSchema;
+}
+function validateModelSchemas(models, schemasProvided, schemasUsed, ctx) {
+    for (const model of models.values()) {
+        if (!schemasProvided.has(model.databaseSchema)) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                message: `Model "${model.name}" references database schema "${model.databaseSchema}" which is not provided.`,
+            });
+            return zod_1.z.NEVER;
+        }
+        schemasUsed.add(model.databaseSchema);
+    }
+}
+function validateEnumSchemas(enums, schemasProvided, schemasUsed, ctx) {
+    for (const e of enums.values()) {
+        if (!schemasProvided.has(e.databaseSchema)) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                message: `Enum "${e.name}" references database schema "${e.databaseSchema}" which is not provided.`,
+            });
+            return zod_1.z.NEVER;
+        }
+        schemasUsed.add(e.databaseSchema);
+    }
+}
+function validateProjectSchemas(schemas, schemasUsed, defaultSchema, ctx) {
+    for (const schema of schemas) {
+        if (!schemasUsed.has(schema)) {
+            // If it is the default schema and it is not used, we assume that this is a work in progress status and we do not throw an error
+            if (schema === defaultSchema) {
+                continue;
+            }
+            // For the same reason, we also skip the config and data schema
+            if (schema === project_schema_defaults_1.databaseSchemaNameConfig || schema === project_schema_defaults_1.databaseSchemaNameData) {
+                continue;
+            }
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                message: `Database schema ${schema} is not used by any model or enum!`,
+            });
+            return zod_1.z.NEVER;
+        }
+    }
+}
+function extractIdField(fields, model, ctx) {
+    for (const field of fields.values()) {
+        if (field.kind === 'id') {
+            return field;
+        }
+    }
+    ctx.addIssue({
+        code: zod_1.z.ZodIssueCode.custom,
+        message: `Model ${model.name} has no id field!`,
+    });
+    return zod_1.z.NEVER;
+}
+function extractDefaultField({ defaultFieldName, ...model }, fields, ctx) {
+    if (defaultFieldName === undefined) {
+        return undefined;
+    }
+    const defaultField = fields.get(defaultFieldName);
+    if (defaultField === undefined) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: `Default field ${defaultFieldName} is not defined in model ${model.name}!`,
+        });
+        return zod_1.z.NEVER;
+    }
+    if (defaultField.kind !== 'scalar' || defaultField.type !== 'boolean') {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: `Default field ${defaultFieldName} in model ${model.name} must be of type \`boolean\`, but instead is of type ${Field.getFieldType(defaultField)}!`,
+        });
+        return zod_1.z.NEVER;
+    }
+    return defaultField;
+}
+function extractLabelField({ labelFieldName, ...model }, fields, ctx) {
+    if (labelFieldName === undefined) {
+        return extractLabelFieldFromNameOrIdField(model, fields, ctx);
+    }
+    const labelField = fields.get(labelFieldName);
+    if (labelField === undefined) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: `Label field ${labelFieldName} is not defined in model ${model.name}!`,
+        });
+        return zod_1.z.NEVER;
+    }
+    if (labelField.kind !== 'scalar' && labelField.kind !== 'id') {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: `Label field ${labelFieldName} in model ${model.name} must be of type \`string\`, but instead is of type ${Field.getFieldType(labelField)}!`,
+        });
+        return zod_1.z.NEVER;
+    }
+    const type = labelField.kind === 'scalar' ? labelField.type : labelField.unbrandedTypeName;
+    if (type !== 'string') {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: `Label field ${labelFieldName} in model ${model.name} must be of type \`string\`, but instead is of type ${type}!`,
+        });
+        return zod_1.z.NEVER;
+    }
+    return labelField;
+}
+function extractLabelFieldFromNameOrIdField({ name }, fields, ctx) {
+    // If no label field is provided, ensure name field exists and use it
+    const fallbackField = fields.get(Field.standardFieldName_name) ?? fields.get(Field.standardFieldName_id);
+    if (fallbackField === undefined) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: `Model ${name} neither provides a \`${Field.standardFieldName_name}\` field nor has \`labelField\` property!`,
+        });
+        return zod_1.z.NEVER;
+    }
+    if (fallbackField.kind !== 'scalar' && fallbackField.kind !== 'id') {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: `If label field is not provided, model ${name} must have a \`${Field.standardFieldName_name}\` field of type \`string\`, but instead is of type ${Field.getFieldType(fallbackField)}!`,
+        });
+        return zod_1.z.NEVER;
+    }
+    return fallbackField;
+}

package/dist/project-schema/project-schema.types.d.ts

@@ -0,0 +1,77 @@
+import * as Enum from '../enum';
+import * as Model from '../model';
+import * as Branded from './project-schema.brands';
+/**
+ * Overall project configuration.
+ *
+ * This includes the models, enums, generators, etc.
+ */
+export type ProjectSchema = {
+    /**
+     * The name of the project, e.g. "Client1 CRM System"
+     */
+    name: Branded.ProjectSchemaName;
+    /**
+     * The slug of the project, e.g. "client1-crm"
+     */
+    slug: string;
+    /**
+     * A helpful description of the project.
+     */
+    description: string;
+    /**
+     * The type of the project. Monorepo projects need to specify their project directory.
+     */
+    projectType: ProjectType;
+    /**
+     * The version of the project/schema. Should follow semantic versioning, see https://semver.org/.
+     */
+    version: string;
+    /**
+     * The database schemas that can be used by models and enums.
+     *
+     * If not provided, the default schemas "PXL" and "Data" are used.
+     */
+    databaseSchemas: Branded.DatabaseSchemaName[];
+    /**
+     * The default database schema that is used if model/enum does not specify a schema.
+     *
+     * If not provided, the default schema "Data" is used.
+     */
+    defaultDatabaseSchema: Branded.DatabaseSchemaName;
+    /**
+     * The system user that is used for root/system tasks, e.g. data seeding.
+     */
+    systemUser: SystemUser;
+    /**
+     * The models that are used in the project.
+     */
+    models: Model.Models;
+    /**
+     * List of model names for easier access.
+     */
+    modelNames: Model.ModelName[];
+    /**
+     * The enums that are used in the project.
+     */
+    enums: Enum.Enums;
+    /**
+     * List of enum names for easier access.
+     */
+    enumNames: Enum.EnumName[];
+    /**
+     * The source definition of the project. Provided to allow custom generators to extract/define additional information.
+     *
+     * Does not contain the models field as this is included in the individual models.
+     */
+    source: Record<string, unknown>;
+};
+export type ProjectType = {
+    kind: 'standalone';
+} | {
+    kind: 'workspace';
+    projectDirectory: string;
+};
+export type SystemUser = Record<string, unknown> & {
+    id: string;
+};

package/dist/project-schema/project-schema.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });