@postxl/generator 0.33.4 → 0.35.0

package/dist/generators/models/businesslogic-view.generator.js

@@ -0,0 +1,253 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateModelBusinessLogicView = void 0;
+const imports_1 = require("../../lib/imports");
+const meta_1 = require("../../lib/meta");
+const fields_1 = require("../../lib/schema/fields");
+const ast_1 = require("../../lib/utils/ast");
+/**
+ * Generates view business logic for a given model.
+ * The view  logic exposes all information and links of a model. See template's readme for more info.
+ */
+function generateModelBusinessLogicView({ model, meta }) {
+    const schemaMeta = (0, meta_1.getSchemaMetadata)({ config: model.schemaConfig });
+    const imports = imports_1.ImportsGenerator.from(meta.businessLogic.view.serviceFilePath);
+    imports.addImports({
+        [meta.data.importPath]: meta.data.repositoryClassName,
+        [meta.types.importPath]: [model.brandedIdType, meta.types.typeName],
+        [schemaMeta.businessLogic.view.serviceFilePath]: schemaMeta.businessLogic.view.serviceClassName,
+        [meta.data.importPath]: [meta.data.repositoryClassName],
+    });
+    /**
+     * The name of the variable that holds the repository instance for the current model
+     * (e.g. when we generate business logic service for Aggregation, the AggregationRepository
+     * would be referenced using `this.data` variable).
+     */
+    const modelRepositoryVariableName = meta.businessLogic.dataRepositoryVariableName;
+    /**
+     * The name of the variable that holds the central business logic service instance.
+     * Instead of injecting a repository instance for each model, we inject this single instance
+     * which then provides access to all models' business logic.
+     */
+    const viewServiceClassName = 'viewService';
+    const constructorParameters = [
+        `public readonly ${modelRepositoryVariableName}: ${meta.data.repositoryClassName}`,
+        `@Inject(forwardRef(() => ${schemaMeta.businessLogic.view.serviceClassName})) private readonly ${viewServiceClassName}: ${schemaMeta.businessLogic.view.serviceClassName}`,
+    ];
+    /**
+     * Variable names and their definitions indexed by the name of the relation they represent.
+     */
+    const variables = new Map();
+    for (const relation of (0, fields_1.getRelationFields)(model)) {
+        const refModel = relation.relationToModel;
+        const refMeta = (0, meta_1.getModelMetadata)({ model: refModel });
+        const variableGetter = `this.${viewServiceClassName}.${refMeta.businessLogic.view.serviceVariableName}.get(itemRaw.${relation.name})`;
+        const variablePresenceCheck = `
+      if (!${relation.relatedModelBacklinkFieldName}) {
+        throw new Error(\`Could not find ${refMeta.types.typeName} with id \${itemRaw.${relation.name}} for ${model.typeName}.${relation.name}!\`)
+      }
+      `;
+        const relationVariableName = relation.relatedModelBacklinkFieldName;
+        variables.set(relation.name, {
+            variableName: relationVariableName,
+            variableDefinition: `
+      const ${relationVariableName} = ${relation.isRequired
+                ? `${variableGetter};${variablePresenceCheck}`
+                : `itemRaw.${relation.name} !== null ? ${variableGetter} : null`} 
+      `,
+        });
+    }
+    const hasLinkedItems = variables.size > 0;
+    if (hasLinkedItems) {
+        imports.addImport({ from: meta.types.importPath, items: [meta.types.linkedTypeName] });
+    }
+    const linkedItemsGetterFn = `
+    /**
+     * Returns the linked ${meta.userFriendlyName} with the given id or null if it does not exist.
+     * Linked: The ${meta.userFriendlyName} contains the linked (raw) items themselves, not only the ids.
+     */
+    public getLinkedItem(id: ${model.brandedIdType}): ${meta.types.linkedTypeName} | null {
+      const itemRaw = this.${modelRepositoryVariableName}.get(id)
+      if (!itemRaw) {
+        return null
+      }
+
+      ${[...variables.values()].map((r) => r.variableDefinition).join('\n')}
+      
+      const item: ${meta.types.linkedTypeName} = {
+        ${model.fields
+        .map((f) => {
+        if (f.kind !== 'relation') {
+            return `${f.name}: itemRaw.${f.name}`;
+        }
+        const linkedRel = variables.get(f.name);
+        if (!linkedRel) {
+            throw new Error(`Could not find linked item for ${model.typeName}.${f.name}`);
+        }
+        return `${linkedRel.variableName}`;
+    })
+        .join(',\n')}
+      }
+
+      return item
+    }
+  `;
+    return `
+import { Inject, Injectable, forwardRef } from '@nestjs/common'
+import { FilterOperator } from '@pxl/common'
+
+${imports.generate()}
+
+@Injectable()
+export class ${meta.businessLogic.view.serviceClassName} {
+  constructor(${constructorParameters.join(',\n')}) {}
+
+  /**
+   * Returns the raw ${meta.userFriendlyName} with the given id or null if it does not exist.
+   * Raw: The ${meta.userFriendlyName} only contains linked Ids, not the linked items themselves.
+   */
+  public get(id: ${model.brandedIdType}): ${meta.types.typeName} | null {
+    return this.${modelRepositoryVariableName}.get(id)
+  }
+
+  ${hasLinkedItems ? linkedItemsGetterFn : ''}
+
+  /**
+   * Returns a map of all ${meta.userFriendlyNamePlural}.
+   */
+  public getAll(): Map<${meta.types.brandedIdType}, ${model.typeName}> {
+    return this.${modelRepositoryVariableName}.getAll()
+  }
+
+  /**
+   * Returns a list of filtered, sorted and paginated ${meta.userFriendlyNamePlural}.
+   */
+  public getList({
+    filter,
+    sort,
+    cursor,
+  }: {
+    filter?: { field: keyof ${model.typeName}; operator: FilterOperator; value: string | number }
+    sort?: { field: keyof ${model.typeName}; ascending: boolean }
+    cursor?: { startRow: number; endRow: number }
+  }) {
+    const items = this.data.getAllAsArray()
+    const filtered = !filter
+      ? items
+      : items.filter((item) => filterFn(item, filter.field, filter.operator, filter.value))
+
+    const filteredAndSorted = !sort
+      ? filtered
+      : filtered.sort((a, b) => (sort.ascending ? compare(a, b, sort.field) : -compare(a, b, sort.field)))
+
+    const paginated = !cursor ? filteredAndSorted : filteredAndSorted.slice(cursor.startRow, cursor.endRow)
+    return { rows: paginated, count: items.length }
+  }
+
+}
+
+// Utility Functions
+
+${_createModelCompareFn({ model })}
+
+${_createModelFilterFn({ model })}
+`;
+}
+exports.generateModelBusinessLogicView = generateModelBusinessLogicView;
+/**
+ * Generates a utility filter function for the given model that can be used to filter out instances
+ * of a model using a given operator on a given field.
+ */
+function _createModelFilterFn({ model }) {
+    const stringFieldFilters = (0, fields_1.getScalarFields)({ fields: model.fields, tsTypeName: 'string' }).map((f) => {
+        return {
+            match: `"${f.name}"`,
+            block: `
+        if (typeof value !== 'string') {
+          return false
+        }
+
+        switch (operator) {
+          case 'contains': {
+            return (item[field] || '').toLowerCase().includes(value.toLowerCase())
+          }
+          default: {
+            return false
+          }
+        }
+      `,
+        };
+    });
+    const numberFieldsFilters = (0, fields_1.getScalarFields)({ fields: model.fields, tsTypeName: 'number' }).map((f) => {
+        return {
+            match: `"${f.name}"`,
+            block: `
+        const toCompare = item[field]
+        if (typeof value !== 'number' || toCompare === null) {
+          return false
+        }
+
+        switch (operator) {
+          case 'eq': {
+            return item[field] === value
+          }
+          case 'gt': {
+            return toCompare > value
+          }
+          case 'lt': {
+            return toCompare < value
+          }
+          default: {
+            return false
+          }
+        }
+      `,
+        };
+    });
+    const fnBlock = (0, ast_1.createSwitchStatement)({
+        field: 'field',
+        cases: [...stringFieldFilters, ...numberFieldsFilters],
+        defaultBlock: 'return false',
+    });
+    return `
+/**
+ * Filters the given ${model.typeName} by the given field, using provided operator and value.
+ */
+function filterFn(
+  item: ${model.typeName}, 
+  field: keyof ${model.typeName}, 
+  operator: FilterOperator, 
+  value: string | number
+): boolean {
+  ${fnBlock}
+}
+`;
+}
+/**
+ * Returns a utility compare function that lets you compare two instances of a given model
+ * by a given field.
+ */
+function _createModelCompareFn({ model }) {
+    const stringFieldComparators = (0, fields_1.getScalarFields)({ fields: model.fields, tsTypeName: 'string' }).map((f) => {
+        return {
+            match: `"${f.name}"`,
+            block: `
+        return (a[field] || '').localeCompare(b[field] || '')
+      `,
+        };
+    });
+    const fnBlock = (0, ast_1.createSwitchStatement)({
+        field: 'field',
+        cases: [...stringFieldComparators],
+        defaultBlock: 'return 0',
+    });
+    return `
+/**
+ * Compares two ${model.typeName} instances by the given field.
+ */
+function compare(a: ${model.typeName}, b: ${model.typeName}, field: keyof ${model.typeName}) {
+  ${fnBlock}
+}
+
+  `;
+}

package/dist/generators/models/react.generator/modals.generator.js

@@ -52,6 +52,9 @@ export const ${modals.createComponentName} = ({ show, onHide }: { show: boolean;
     () => createTypedForm<CreateInputData>().with({ ${(() => {
         const components = new Set();
         for (const field of fields.values()) {
+            if (field.attributes.isReadonly) {
+                continue;
+            }
             switch (field.kind) {
                 case 'enum': {
                     const enumMeta = (0, meta_1.getEnumMetadata)({ enumerator: field.enumerator });
@@ -79,7 +82,7 @@ export const ${modals.createComponentName} = ({ show, onHide }: { show: boolean;
       <Typed.Formik
         initialValues={{
 					${fields
-        .filter((f) => f.kind !== 'id')
+        .filter((f) => f.kind !== 'id' && !f.attributes.isReadonly)
         .map((field) => `${getFormikFieldName(field.name)}: null,`)
         .join('\n')}
 				}}
@@ -195,6 +198,7 @@ export const ${components.modals.editComponentName} = ({
       <Typed.Formik
         initialValues={{
 					${fields
+        .filter((f) => !f.attributes.isReadonly || f.kind === 'id')
         .map((field) => {
         switch (field.kind) {
             case 'enum':
@@ -387,6 +391,9 @@ function getFormImports({ model, meta }) {
 function getCreateFormInputFields({ model }) {
     const form = new serializer_1.Serializer();
     for (const field of model.fields.values()) {
+        if (field.attributes.isReadonly) {
+            continue;
+        }
         switch (field.kind) {
             case 'id':
                 continue;
@@ -407,12 +414,13 @@ function getCreateFormInputFields({ model }) {
 }
 function getFormikCreateMutationData({ model: { fields } }) {
     return fields
+        .filter((f) => !f.attributes.isReadonly)
         .map((field) => {
         const formikFieldName = getFormikFieldName(field.name);
         switch (field.kind) {
             case 'id':
             case 'scalar':
-                // NOTE: Create methods generate the ID field upon submision.
+                // NOTE: Create methods generate the ID field upon submission.
                 if (field.kind === 'id') {
                     return '';
                 }
@@ -454,6 +462,9 @@ function getFormikCreateMutationData({ model: { fields } }) {
 function getEditFormInputFields({ model }) {
     const form = new serializer_1.Serializer();
     for (const field of model.fields.values()) {
+        if (field.attributes.isReadonly) {
+            continue;
+        }
         switch (field.kind) {
             case 'id':
                 continue;
@@ -489,6 +500,7 @@ function getEditFormInputFields({ model }) {
 }
 function getEditFormikMutationData({ model: { fields } }) {
     return fields
+        .filter((f) => !f.attributes.isReadonly || f.kind === 'id')
         .map((field) => {
         const formikFieldName = getFormikFieldName(field.name);
         switch (field.kind) {
@@ -520,11 +532,15 @@ function getFormFieldComponents({ model }) {
     var _a;
     const form = new serializer_1.Serializer();
     for (const field of model.fields.values()) {
+        // By default, we hide generated fields like createdAt, updatedAt, deletedAt.
+        if (field.attributes.isReadonly) {
+            continue;
+        }
         const formikFieldName = getFormikFieldName(field.name);
         const label = StringUtils.toPascalCase(field.name);
         switch (field.kind) {
             case 'id': {
-                // NOTE: We never show the ID field in the form even if it's in the type signiture of the form input.
+                // NOTE: We never show the ID field in the form even if it's in the type signature of the form input.
                 break;
             }
             case 'scalar': {
@@ -604,7 +620,7 @@ function getFormFieldComponents({ model }) {
 function getFormikValidationCases({ model }) {
     const form = new serializer_1.Serializer();
     for (const field of model.fields.values()) {
-        if (field.kind === 'id') {
+        if (field.kind === 'id' || field.attributes.isReadonly) {
             continue;
         }
         const formikFieldName = getFormikFieldName(field.name);

package/dist/generators/models/repository.generator.d.ts

@@ -31,6 +31,10 @@ type FnSignature = {
      * The return type of the function.
      */
     returnType: string;
+    /**
+     * The JSDoc comment of the function.
+     */
+    jsDoc?: string[];
 };
 /**
  * Returns a collection of type signatures for the repository methods of a given model.
@@ -40,7 +44,12 @@ export declare function getRepositoryMethodsTypeSignatures({ model, meta }: {
     meta: ModelMetaData;
 }): {
     create: FnSignature;
+    createMany: FnSignature;
     update: FnSignature;
+    updateMany: FnSignature;
+    upsert: FnSignature;
+    upsertMany: FnSignature;
     delete: FnSignature;
+    deleteMany: FnSignature;
 };
 export {};