@postxl/generator 0.39.0 → 0.40.1

package/dist/lib/schema/types.d.ts

@@ -1,3 +1,44 @@
+/**
+ * The name of a class, e.g. "AggregationRepository".
+ */
+export type ClassName = string & {
+    readonly ___type: 'ClassName';
+};
+/**
+ * Converts a raw string to a branded ClassName.
+ */
+export declare const toClassName: (t: string) => ClassName;
+/**
+ * Name of a "Discriminant" in a "Discriminated Union".
+ *
+ * (Background)[https://www.typescriptlang.org/docs/handbook/2/narrowing.html#discriminated-unions]:
+ * A "discriminated union" in TypeScript is a union type with a common, singleton type property — the discriminant.
+ * E.g.:
+ * ```ts
+ * type Shape = Square | Rectangle | Circle
+ * type Square = { kind: "square"; size: number }
+ * type Rectangle = { kind: "rectangle"; width: number; height: number }
+ * type Circle = { kind: "circle"; radius: number }
+ * ```
+ * In the above example, the `kind` property is the discriminant.
+ */
+export type DiscriminantName = string & {
+    readonly ___type: 'DiscriminantName';
+};
+/**
+ * Brands a raw string as a discriminant.
+ */
+export declare const toDiscriminantName: (t: string) => DiscriminantName;
+/**
+ * The name of a model, e.g. "Aggregation".
+*/
+export type ModelName = string & {
+    readonly ___type: 'ModelName';
+};
+/**
+ * Brands a raw string to a ModelName identifier.
+ */
+export declare const toModelName: (t: string) => ModelName;
 /**
  * Name of a Typescript type, e.g. "Aggregation".
  */
@@ -9,25 +50,35 @@ export type TypeName = string & {
  */
 export declare const toTypeName: (t: string) => TypeName;
 /**
- * The name of a function (e.g. "toAggregation").
- */
-export type Fnction = string & {
-    readonly ___type: 'FunctionName';
+ * The name of a model field, e.g. "name".
+*/
+export type FieldName = string & {
+    readonly ___type: 'FieldName';
 };
 /**
- * Converts a string to a branded function name.
+ * Brands a raw string to a FieldName identifier.
  */
-export declare const toFunction: (t: string) => Fnction;
+export declare const toFieldName: (t: string) => FieldName;
 /**
- * The name of a class, e.g. "AggregationRepository".
+ * The name of an Enum, e.g. "Language".
+*/
+export type EnumName = string & {
+    readonly ___type: 'EnumName';
+};
+/**
+ * Brands a raw string to an EnumName identifier.
  */
-export type ClassName = string & {
-    readonly ___type: 'ClassName';
+export declare const toEnumName: (t: string) => EnumName;
+/**
+ * The name of a function (e.g. "toAggregation").
+*/
+export type FunctionName = string & {
+    readonly ___type: 'FunctionName';
 };
 /**
- * Converts a raw string to a branded ClassName.
+ * Converts a string to a branded function name.
  */
-export declare const toClassName: (t: string) => ClassName;
+export declare const toFunctionName: (t: string) => FunctionName;
 /**
  * The name of a variable or a property in the generated code.
  */
@@ -73,4 +124,4 @@ export declare const toPath: (t: string) => Path;
 /**
  * Branded string values that can be used as import statement values in the generators
  */
-export type ImportableTypes = Fnction | ClassName | TypeName | VariableName;
+export type ImportableTypes = FunctionName | ClassName | TypeName | VariableName;

package/dist/lib/schema/types.js

@@ -1,22 +1,42 @@
 "use strict";
 // MARK: - Generated content related types
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toPath = exports.toFolderName = exports.toFileName = exports.toVariableName = exports.toClassName = exports.toFunction = exports.toTypeName = void 0;
+exports.toPath = exports.toFolderName = exports.toFileName = exports.toVariableName = exports.toFunctionName = exports.toEnumName = exports.toFieldName = exports.toTypeName = exports.toModelName = exports.toDiscriminantName = exports.toClassName = void 0;
+/**
+ * Converts a raw string to a branded ClassName.
+ */
+const toClassName = (t) => t;
+exports.toClassName = toClassName;
+/**
+ * Brands a raw string as a discriminant.
+ */
+const toDiscriminantName = (t) => t;
+exports.toDiscriminantName = toDiscriminantName;
+/**
+ * Brands a raw string to a ModelName identifier.
+ */
+const toModelName = (t) => t;
+exports.toModelName = toModelName;
 /**
  * Brands a raw string to a TypeScript Type identifier.
  */
 const toTypeName = (t) => t;
 exports.toTypeName = toTypeName;
 /**
- * Converts a string to a branded function name.
+ * Brands a raw string to a FieldName identifier.
  */
-const toFunction = (t) => t;
-exports.toFunction = toFunction;
+const toFieldName = (t) => t;
+exports.toFieldName = toFieldName;
 /**
- * Converts a raw string to a branded ClassName.
+ * Brands a raw string to an EnumName identifier.
  */
-const toClassName = (t) => t;
-exports.toClassName = toClassName;
+const toEnumName = (t) => t;
+exports.toEnumName = toEnumName;
+/**
+ * Converts a string to a branded function name.
+ */
+const toFunctionName = (t) => t;
+exports.toFunctionName = toFunctionName;
 /**
  * Converts a string to a branded VariableName.
  */

package/dist/lib/utils/string.d.ts

@@ -31,5 +31,6 @@ export declare const conjugateNames: (name: string) => {
     pluralized: string;
     uncapitalizedPlural: string;
     uncapitalized: string;
+    capitalized: string;
     capitalizedPlural: string;
 };

package/dist/lib/utils/string.js

@@ -53,6 +53,9 @@ const irregularPlurals = {
     datum: 'data',
     diagnosis: 'diagnoses',
     focus: 'foci',
+    // While `histories` is the plural of `history`, in a model context, `history` makes more sense:
+    // If you have a model called `UserHistory`, calling the table `UserHistories` would be confusing.
+    history: 'history',
     hypothesis: 'hypotheses',
     index: 'indices',
     matrix: 'matrices',
@@ -113,6 +116,7 @@ const conjugateNames = (name) => ({
     pluralized: (0, exports.capitalize)((0, exports.pluralize)(name)),
     uncapitalizedPlural: (0, exports.uncapitalize)((0, exports.pluralize)(name)),
     uncapitalized: (0, exports.uncapitalize)(name),
+    capitalized: (0, exports.capitalize)(name),
     capitalizedPlural: (0, exports.capitalize)((0, exports.pluralize)(name)),
 });
 exports.conjugateNames = conjugateNames;

package/dist/prisma/parse.js

@@ -62,7 +62,7 @@ function isModelNotIgnored(model) {
 function parseModelCore({ dmmfModel, config, }) {
     const attributes = (0, attributes_1.getModelAttributes)(dmmfModel);
     return {
-        name: (0, string_1.toPascalCase)(dmmfModel.name),
+        name: Types.toModelName((0, string_1.toPascalCase)(dmmfModel.name)),
         description: attributes.description,
         typeName: Types.toTypeName((0, string_1.toPascalCase)(dmmfModel.name)),
         sourceName: dmmfModel.name,
@@ -121,7 +121,7 @@ function parseModel({ dmmfModel, enums, models, config, }) {
         .map((dmmfField) => {
         const attributes = (0, attributes_1.getFieldAttributes)(dmmfField);
         const shared = {
-            name: (0, string_1.toCamelCase)(dmmfField.name),
+            name: Types.toFieldName((0, string_1.toCamelCase)(dmmfField.name)),
             description: attributes.description,
             sourceName: dmmfField.name,
             isRequired: dmmfField.isRequired,
@@ -136,7 +136,7 @@ function parseModel({ dmmfModel, enums, models, config, }) {
             if (!refField) {
                 (0, error_1.throwError)(`Investigate: Relation field ${dmmfField.name} not found.`);
             }
-            return Object.assign(Object.assign({ kind: 'relation' }, shared), { relatedModelBacklinkFieldName: refField.name, typeName: Types.toTypeName(dmmfField.type), unbrandedTypeName: getTsTypeForId(dmmfField), relationToModel: refModel });
+            return Object.assign(Object.assign({ kind: 'relation' }, shared), { relatedModelBacklinkFieldName: Types.toFieldName(refField.name), typeName: Types.toTypeName(dmmfField.type), unbrandedTypeName: getTsTypeForId(dmmfField), relationToModel: refModel });
         }
         if (dmmfField.isId) {
             const isGeneratedField = isAutoIncrementField(dmmfField) || isUUIDField(dmmfField);
@@ -281,7 +281,7 @@ function isFieldIgnored({ field }) {
 function parseEnum({ dmmfEnum, config }) {
     const attributes = (0, attributes_1.getEnumAttributes)(dmmfEnum);
     return {
-        name: dmmfEnum.name,
+        name: Types.toEnumName(dmmfEnum.name),
         description: attributes.description,
         attributes,
         tsTypeName: Types.toTypeName((0, string_1.toPascalCase)(dmmfEnum.name)),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@postxl/generator",
-  "version": "0.39.0",
+  "version": "0.40.1",
   "main": "./dist/generator.js",
   "typings": "./dist/generator.d.ts",
   "bin": {

package/dist/generators/indices/seed-service.generator.js

@@ -1,354 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateSeedService = void 0;
-const meta_1 = require("../../lib/meta");
-/**
- * Generates index file for all seed files.
- */
-function generateSeedService({ models }) {
-    const creates = [];
-    const updates = [];
-    const upserts = [];
-    const deletes = [];
-    for (const model of models) {
-        const modelMeta = (0, meta_1.getModelMetadata)({ model });
-        creates.push(`await this.create({ name: '${modelMeta.userFriendlyName}', data: data.${modelMeta.seed.constantName}?.create, repo: this.dataService.${modelMeta.data.dataServiceName}, execution })`);
-        updates.push(`await this.update({ name: '${modelMeta.userFriendlyName}', data: data.${modelMeta.seed.constantName}?.update, repo: this.dataService.${modelMeta.data.dataServiceName}, execution })`);
-        upserts.push(`await this.upsert({ name: '${modelMeta.userFriendlyName}', data: data.${modelMeta.seed.constantName}?.upsert, repo: this.dataService.${modelMeta.data.dataServiceName}, execution })`);
-        deletes.push(`await this.delete({ name: '${modelMeta.userFriendlyName}', data: data.${modelMeta.seed.constantName}?.delete, repo: this.dataService.${modelMeta.data.dataServiceName}, execution })`);
-    }
-    return /* ts */ `
-import { Injectable, Logger } from '@nestjs/common'
-import { ExhaustiveSwitchCheck, format, pluralize } from '@pxl/common'
-import { DataService, Repository } from '@pxl/data'
-import { DbService } from '@pxl/db'
-import { XlPortService } from '@pxl/xlport'
-
-import { IActionExecution, DispatcherService } from '@pxl/actions'
-
-import {
-  ActionPreparation_Seed,
-  ActionPreparation_Seed_Excel,
-  Action_Seed,
-  Action_Seed_CustomLogic,
-  Action_Seed_Excel,
-  createActionSeedExcel,
-} from './action.types'
-import { SeedData } from './seed-data.type'
-import { CreateDTO, UpdateDTO } from '@pxl/types'
-import { SEED_MIGRATIONS } from '@pxl/seed-data'
-
-// If true, the seed data will be created/updated one by one, instead of all at once (which is the default).
-// Also, each item will be logged to the console.
-// This should help to quickly identify the item that causes an error in a bulk operation.
-const DEBUG = false
-
-@Injectable()
-export class SeedService {
-  private readonly logger = new Logger(SeedService.name)
-
-  constructor(
-    private readonly dataService: DataService,
-    private readonly xlPortService: XlPortService,
-    private readonly dbService: DbService,
-    private readonly dispatcherService: DispatcherService,
-  ) {
-    dispatcherService.seedService = this
-  }
-
-  /**
-   * To be called on application startup. Will validate the seed data migrations and execute any pending migrations.
-   *
-   * Each migration is an action, i.e. will be dispatched via the default dispatcher service and logged like any other action.
-   */
-  public async seed() {
-    this.verifyIntegrity()
-
-    let executed = 0
-    for (const migration of SEED_MIGRATIONS) {
-      // Skip any migrations that have already been executed
-      const migrationExists = await this.dbService.action.findFirst({
-        where: { migrationOrder: migration.order, status: 'Success' },
-      })
-      if (migrationExists) {
-        continue
-      }
-
-      const action = await this.convertToAction(migration)
-
-      this.logger.log(\`Executing seed migration \${migration.order} - \${migration.name}\`)
-      await this.dispatcherService.dispatch({ action, user: this.dataService.users.rootUser })
-
-      executed++
-    }
-
-    if (executed === 0) {
-      if (SEED_MIGRATIONS.length > 0) {
-        this.logger.log(\`✅ All \${format(SEED_MIGRATIONS.length)} seed migrations have already been applied executed\`)
-      } else {
-        this.logger.log(\`No seed migrations found.\`)
-      }
-    } else {
-      if (executed === SEED_MIGRATIONS.length) {
-        this.logger.log(\`✅ Executed all \${format(executed)} seed migrations\`)
-      } else {
-        this.logger.log(
-          \`✅ Executed \${format(executed)} seed migrations, skipped \${format(SEED_MIGRATIONS.length - executed)} previous migrations\`,
-        )
-      }
-    }
-  }
-
-  private async convertToAction(migration: ActionPreparation_Seed): Promise<Action_Seed> {
-    switch (migration.type) {
-      case 'data':
-        return migration
-      case 'excel':
-        return await this.convertExcelToAction(migration)
-      case 'custom':
-        return migration
-      default:
-        throw new ExhaustiveSwitchCheck(migration)
-    }
-  }
-
-  /**
-   * Will be call by the dispatcher service to dispatch the given action.
-   */
-  public async dispatch({ action, execution }: { action: Action_Seed; execution: IActionExecution }) {
-    switch (action.type) {
-      case 'data':
-        return this.uploadDataSteps({ steps: action.payload, execution })
-      case 'excel':
-        return this.uploadData({ data: action.payload.data, execution })
-      case 'custom':
-        return this.handleCustomLogic({ action, execution })
-
-      default:
-        throw new ExhaustiveSwitchCheck(action)
-    }
-  }
-
-  /**
-   * Checks if the order of the migrations is correct and if there are any missing migrations.
-   */
-  private verifyIntegrity() {
-    let startOrder = 0
-    for (const { name, order } of SEED_MIGRATIONS) {
-      if (order <= startOrder) {
-        throw new Error(
-          \`Invalid migration order. The order of migration "\${name}" must be after \${startOrder} but is \${order}. Is the order field correct and the order in the SEED_MIGRATIONS array correct?\`,
-        )
-      }
-      startOrder = order
-    }
-  }
-
-  /**
-   * Reads the Excel file and parses it using the provided decoder.
-   * If the parsing is successful, the data is packaged into an Action_Seed_Excel.
-   */
-  private async convertExcelToAction({
-    name,
-    order,
-    filename,
-    decoder,
-  }: ActionPreparation_Seed_Excel): Promise<Action_Seed_Excel> {
-    const xlData = await this.xlPortService.importFromFile(filename)
-    if (xlData.status === 'error') {
-      this.logger.error(xlData.message)
-      throw new Error(\`Error importing Excel data\`)
-    }
-
-    const dataParsed = decoder.safeParse(xlData.data.tables)
-    if (!dataParsed.success) {
-      this.logger.error(dataParsed.error.message)
-      throw new Error(\`Error parsing Excel seed data\`)
-    }
-
-    return createActionSeedExcel({ name, order, filename, data: dataParsed.data })
-  }
-
-  /**
-   * Executes the custom logic of the given migration.
-   * To do this, we retrieve the handler from the migration and call it, injecting the data service into the handler.
-   */
-  private handleCustomLogic({ action, execution }: { action: Action_Seed_CustomLogic; execution: IActionExecution }) {
-    const actionPreparation = SEED_MIGRATIONS.find((m) => m.order === action.order)
-    if (!actionPreparation) {
-      throw new Error(\`Cannot find custom handler for migration with order \${action.order}\`)
-    }
-    if (actionPreparation.type !== 'custom') {
-      throw new Error(\`Cannot find custom handler for migration with order \${action.order}\`)
-    }
-    return actionPreparation.handler({ action, data: this.dataService, execution })
-  }
-  /**
-   * Executes the data loading step by step
-   */
-  private async uploadDataSteps({ steps, execution }: { steps: SeedData[]; execution: IActionExecution }) {
-    let index = 0
-    for (const step of steps) {
-      this.logger.log(\`Uploading data step \${++index}/\${steps.length}\`)
-      await this.uploadData({ data: step, execution })
-    }
-  }
-
-  private async uploadData({ data, execution }: { data: SeedData; execution: IActionExecution }) {
-    // NOTE: the order of these calls is important, because of foreign key constraints
-    // The current order is based on the order of the models in the schema
-    // Change the order based on your needs.
-    // Attention: Depending on the dependencies in seed data, you may also have to take care of relations,
-    // e.g. by removing any foreign key first - and then update these after all data is created.
-    // Alternatively, you can also do this in multiple steps
-    ${creates.join('\n')}
-
-    ${updates.join('\n')}
-
-    ${upserts.join('\n')}
-
-    ${deletes.join('\n')}
-  }
-
-  private async create<T extends { id: ID }, ID extends number | string | boolean>({
-    name,
-    data,
-    repo,
-    execution,
-  }: {
-    name: string
-    data: CreateDTO<T, ID>[] | undefined
-    repo: Repository<T, ID>
-    execution: IActionExecution
-  }): Promise<void> {
-    if (!data) {
-      return
-    }
-    if (!DEBUG) {
-      await repo.createMany?.({ items: data, execution })
-    } else {
-      let i = 0
-      for (const item of data) {
-        i++
-        this.logger.log(\`Creating \${name} \${i} - \${getItemDescription(item)}\`)
-        try {
-          await repo.create?.({ item, execution })
-        } catch (error) {
-          this.logger.error(\`Error creating \${name} \${i} - \${getItemDescription(item)}\`, error)
-          throw error
-        }
-      }
-    }
-    this.logger.log(\`✅ Created \${format(data.length)} \${pluralize(name)}\`)
-  }
-  
-  private async update<T extends { id: ID }, ID extends number | string | boolean>({
-    name,
-    data,
-    repo,
-    execution,
-  }: {
-    name: string
-    data: UpdateDTO<T, ID>[] | undefined
-    repo: Repository<T, ID>
-    execution: IActionExecution
-  }): Promise<void> {
-    if (!data) {
-      return
-    }
-    if (!DEBUG) {
-      await repo.updateMany?.({ items: data, execution })
-    } else {
-      let i = 0
-      for (const item of data) {
-        i++
-        this.logger.log(\`Updating \${name} \${i} - \${getItemDescription(item)}\`)
-        try {
-          await repo.update?.({ item, execution })
-        } catch (error) {
-          this.logger.error(\`Error updating \${name} \${i} - \${getItemDescription(item)}\`, error)
-          throw error
-        }
-      }
-    }
-    this.logger.log(\`✅ Updated \${format(data.length)} \${pluralize(name)}\`)
-  }
-
-  private async upsert<T extends { id: ID }, ID extends number | string | boolean>({
-    name,
-    data,
-    repo,
-    execution,
-  }: {
-    name: string
-    data: (CreateDTO<T, ID> | UpdateDTO<T, ID>)[] | undefined
-    repo: Repository<T, ID>
-    execution: IActionExecution
-  }): Promise<void> {
-    if (!data) {
-      return
-    }
-    if (!DEBUG) {
-      await repo.upsertMany?.({ items: data, execution })
-    } else {
-      let i = 0
-      for (const item of data) {
-        i++
-        this.logger.log(\`Upserting \${name} \${i} - \${getItemDescription(item)}\`)
-        try {
-          await repo.upsert?.({ item, execution })
-        } catch (error) {
-          this.logger.error(\`Error upserting \${name} \${i} - \${getItemDescription(item)}\`, error)
-          throw error
-        }
-      }
-    }
-    this.logger.log(\`✅ Upserted \${format(data.length)} \${pluralize(name)}\`)
-  }
-
-  private async delete<T extends { id: ID }, ID extends number | string | boolean>({
-    name,
-    data,
-    repo,
-    execution,
-  }: {
-    name: string
-    data: ID[] | undefined
-    repo: Repository<T, ID>
-    execution: IActionExecution
-  }): Promise<void> {
-    if (!data) {
-      return
-    }
-    if (!DEBUG) {
-      await repo.deleteMany?.({ ids: data, execution })
-    } else {
-      let i = 0
-      for (const id of data) {
-        i++
-        this.logger.log(\`Deleting \${name} \${i} - id: \${id.toString()}\`)
-        try {
-          await repo.delete?.({ id, execution })
-        } catch (error) {
-          this.logger.error(\`Error deleting \${name} \${i} - id: \${id.toString()}\`, error)
-          throw error
-        }
-      }
-    }
-    this.logger.log(\`✅ Deleted \${format(data.length)} \${pluralize(name)}\`)
-  }
-}
-
-function getItemDescription<T extends Partial<{ id: ID }>, ID extends number | string | boolean>(item: T): string {
-  const id = \`id: \${item.id !== undefined ? item.id.toString() : 'not provided'}\`
-
-  // If the item has a name, we can assume it is a string and add it to the description
-  if ('name' in item) {
-    // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-    return \`\${id}, name: \${item.name}\`
-  }
-  return id
-}
-`;
-}
-exports.generateSeedService = generateSeedService;