@postxl/generators 0.2.2

package/dist/backend-data-management/template/data-management.controller.ts

@@ -0,0 +1,242 @@
+import { Controller, Get, Logger, Post, Req, Res } from '@nestjs/common'
+
+import { FastifyReply, FastifyRequest } from 'fastify'
+
+import { DataManagementService } from './data-management.service'
+
+@Controller('data-management')
+export class DataManagementController {
+  private readonly logger = new Logger(DataManagementController.name)
+
+  constructor(private readonly dataManagementService: DataManagementService) {}
+
+  // ============================================================================
+  // Export Endpoints
+  // ============================================================================
+
+  @Post('export-raw-excel')
+  async exportRawExcel(@Req() req: FastifyRequest, @Res({ passthrough: true }) res: FastifyReply): Promise<void> {
+    try {
+      const data = await req.file()
+      if (!data) {
+        throw new Error('No file uploaded')
+      }
+      const fileBuffer = await data.toBuffer()
+      const { filename, data: exportData } = await this.dataManagementService.exportRawExcel(fileBuffer)
+
+      const json = JSON.stringify(exportData, null, 2)
+
+      res.type('application/json')
+      res.header('Content-Disposition', `attachment; filename="${filename}"`)
+      res.header('Access-Control-Expose-Headers', 'Content-Disposition')
+      res.send(json)
+    } catch (error) {
+      this.logger.error('Error exporting raw Excel data', error)
+      res.status(500).send({ error: error instanceof Error ? error.message : String(error) })
+    }
+  }
+
+  @Post('export-processed-excel')
+  async exportProcessedExcel(@Req() req: FastifyRequest, @Res({ passthrough: true }) res: FastifyReply): Promise<void> {
+    try {
+      const data = await req.file()
+      if (!data) {
+        throw new Error('No file uploaded')
+      }
+      const fileBuffer = await data.toBuffer()
+      const { filename, data: exportData } = await this.dataManagementService.exportProcessedExcel(fileBuffer)
+
+      const json = JSON.stringify(exportData, null, 2)
+
+      res.type('application/json')
+      res.header('Content-Disposition', `attachment; filename="${filename}"`)
+      res.header('Access-Control-Expose-Headers', 'Content-Disposition')
+      res.send(json)
+    } catch (error) {
+      this.logger.error('Error exporting processed Excel data', error)
+      res.status(500).send({ error: error instanceof Error ? error.message : String(error) })
+    }
+  }
+
+  @Get('export-database-excel-format')
+  async exportDatabaseExcelFormat(@Res({ passthrough: true }) res: FastifyReply): Promise<void> {
+    try {
+      const { filename, data } = await this.dataManagementService.exportDatabaseExcelFormat()
+
+      const json = JSON.stringify(data, null, 2)
+
+      res.type('application/json')
+      res.header('Content-Disposition', `attachment; filename="${filename}"`)
+      res.header('Access-Control-Expose-Headers', 'Content-Disposition')
+      res.send(json)
+    } catch (error) {
+      this.logger.error('Error exporting database to Excel format', error)
+      res.status(500).send({ error: error instanceof Error ? error.message : String(error) })
+    }
+  }
+
+  @Get('export-database-json-format')
+  async exportDatabaseJsonFormat(@Res({ passthrough: true }) res: FastifyReply): Promise<void> {
+    try {
+      const { filename, data } = await this.dataManagementService.exportDatabaseJsonFormat()
+
+      const json = JSON.stringify(data, null, 2)
+
+      res.type('application/json')
+      res.header('Content-Disposition', `attachment; filename="${filename}"`)
+      res.header('Access-Control-Expose-Headers', 'Content-Disposition')
+      res.send(json)
+    } catch (error) {
+      this.logger.error('Error exporting database to JSON format', error)
+      res.status(500).send({ error: error instanceof Error ? error.message : String(error) })
+    }
+  }
+
+  // ============================================================================
+  // Seed Endpoints (Clear DB + Import)
+  // ============================================================================
+
+  @Post('seed-from-raw-excel')
+  async seedFromRawExcel(@Req() req: FastifyRequest, @Res({ passthrough: true }) res: FastifyReply): Promise<any> {
+    try {
+      const data = await req.file()
+      if (!data) {
+        throw new Error('No file uploaded')
+      }
+      const fileBuffer = await data.toBuffer()
+      const result = await this.dataManagementService.seedFromRawExcel(fileBuffer, data.filename)
+      res.status(200).send(result)
+    } catch (error) {
+      this.logger.error('Error seeding from raw Excel data', error)
+      res.status(500).send({ success: false, error: error instanceof Error ? error.message : String(error) })
+    }
+  }
+
+  @Post('seed-from-decoded-json')
+  async seedFromDecodedJson(@Req() req: FastifyRequest, @Res({ passthrough: true }) res: FastifyReply): Promise<any> {
+    try {
+      const data = await req.file()
+      if (!data) {
+        throw new Error('No file uploaded')
+      }
+      const fileBuffer = await data.toBuffer()
+      const result = await this.dataManagementService.seedFromDecodedJson(fileBuffer)
+      res.status(200).send(result)
+    } catch (error) {
+      this.logger.error('Error seeding from decoded JSON', error)
+      res.status(500).send({ success: false, error: error instanceof Error ? error.message : String(error) })
+    }
+  }
+
+  @Post('seed-from-excel-formatted-json')
+  async seedFromExcelFormattedJson(
+    @Req() req: FastifyRequest,
+    @Res({ passthrough: true }) res: FastifyReply,
+  ): Promise<any> {
+    try {
+      const data = await req.file()
+      if (!data) {
+        throw new Error('No file uploaded')
+      }
+      const fileBuffer = await data.toBuffer()
+      const result = await this.dataManagementService.seedFromExcelFormattedJson(fileBuffer)
+      res.status(200).send(result)
+    } catch (error) {
+      this.logger.error('Error seeding from Excel-formatted JSON', error)
+      res.status(500).send({ success: false, error: error instanceof Error ? error.message : String(error) })
+    }
+  }
+
+  @Post('seed-from-json-formatted-json')
+  async seedFromJsonFormattedJson(
+    @Req() req: FastifyRequest,
+    @Res({ passthrough: true }) res: FastifyReply,
+  ): Promise<any> {
+    try {
+      const data = await req.file()
+      if (!data) {
+        throw new Error('No file uploaded')
+      }
+      const fileBuffer = await data.toBuffer()
+      const result = await this.dataManagementService.seedFromJsonFormattedJson(fileBuffer)
+      res.status(200).send(result)
+    } catch (error) {
+      this.logger.error('Error seeding from JSON-formatted JSON', error)
+      res.status(500).send({ success: false, error: error instanceof Error ? error.message : String(error) })
+    }
+  }
+
+  // ============================================================================
+  // Update Endpoints (Delta Detection + Import)
+  // ============================================================================
+
+  @Post('update-from-raw-excel')
+  async updateFromRawExcel(@Req() req: FastifyRequest, @Res({ passthrough: true }) res: FastifyReply): Promise<any> {
+    try {
+      const data = await req.file()
+      if (!data) {
+        throw new Error('No file uploaded')
+      }
+      const fileBuffer = await data.toBuffer()
+      const result = await this.dataManagementService.updateFromRawExcel(fileBuffer, data.filename)
+      res.status(200).send(result)
+    } catch (error) {
+      this.logger.error('Error updating from raw Excel data', error)
+      res.status(500).send({ success: false, error: error instanceof Error ? error.message : String(error) })
+    }
+  }
+
+  @Post('update-from-decoded-json')
+  async updateFromDecodedJson(@Req() req: FastifyRequest, @Res({ passthrough: true }) res: FastifyReply): Promise<any> {
+    try {
+      const data = await req.file()
+      if (!data) {
+        throw new Error('No file uploaded')
+      }
+      const fileBuffer = await data.toBuffer()
+      const result = await this.dataManagementService.updateFromDecodedJson(fileBuffer)
+      res.status(200).send(result)
+    } catch (error) {
+      this.logger.error('Error updating from decoded JSON', error)
+      res.status(500).send({ success: false, error: error instanceof Error ? error.message : String(error) })
+    }
+  }
+
+  @Post('update-from-excel-formatted-json')
+  async updateFromExcelFormattedJson(
+    @Req() req: FastifyRequest,
+    @Res({ passthrough: true }) res: FastifyReply,
+  ): Promise<any> {
+    try {
+      const data = await req.file()
+      if (!data) {
+        throw new Error('No file uploaded')
+      }
+      const fileBuffer = await data.toBuffer()
+      const result = await this.dataManagementService.updateFromExcelFormattedJson(fileBuffer)
+      res.status(200).send(result)
+    } catch (error) {
+      this.logger.error('Error updating from Excel-formatted JSON', error)
+      res.status(500).send({ success: false, error: error instanceof Error ? error.message : String(error) })
+    }
+  }
+
+  @Post('update-from-json-formatted-json')
+  async updateFromJsonFormattedJson(
+    @Req() req: FastifyRequest,
+    @Res({ passthrough: true }) res: FastifyReply,
+  ): Promise<any> {
+    try {
+      const data = await req.file()
+      if (!data) {
+        throw new Error('No file uploaded')
+      }
+      const fileBuffer = await data.toBuffer()
+      const result = await this.dataManagementService.updateFromJsonFormattedJson(fileBuffer)
+      res.status(200).send(result)
+    } catch (error) {
+      this.logger.error('Error updating from JSON-formatted JSON', error)
+      res.status(500).send({ success: false, error: error instanceof Error ? error.message : String(error) })
+    }
+  }
+}

package/dist/backend-data-management/template/data-management.module.ts

@@ -0,0 +1,15 @@
+import { ActionsModule } from '@actions/actions.module'
+import { forwardRef, Module } from '@nestjs/common'
+import { RepositoriesModule } from '@repositories/repositories.module'
+import { XlPortModule } from '@xlport/xlport.module'
+
+import { DataManagementController } from './data-management.controller'
+import { DataManagementService } from './data-management.service'
+
+@Module({
+  imports: [RepositoriesModule, XlPortModule, forwardRef(() => ActionsModule)],
+  controllers: [DataManagementController],
+  providers: [DataManagementService],
+  exports: [DataManagementService],
+})
+export class DataManagementModule {}

package/dist/backend-database-prisma/generators/database-config.generator.d.ts

@@ -0,0 +1,2 @@
+import { DatabaseContext } from '../prisma.generator';
+export declare function generateDatabaseConfig({ config }: DatabaseContext): string;

package/dist/backend-database-prisma/generators/database-config.generator.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDatabaseConfig = generateDatabaseConfig;
+function generateDatabaseConfig({ config }) {
+    return /* ts */ `
+import { Injectable } from '@nestjs/common'
+
+export type ${config.type.name} = Readonly<{
+  readonly connectionString: string
+}>
+
+@Injectable()
+export class ${config.name} {
+  constructor(public readonly config: ${config.type.name}) { }
+}
+`;
+}
+//# sourceMappingURL=database-config.generator.js.map

package/dist/backend-database-prisma/generators/database-config.generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"database-config.generator.js","sourceRoot":"","sources":["../../../src/backend-database-prisma/generators/database-config.generator.ts"],"names":[],"mappings":";;AAEA,wDAaC;AAbD,SAAgB,sBAAsB,CAAC,EAAE,MAAM,EAAmB;IAChE,OAAO,QAAQ,CAAC;;;cAGJ,MAAM,CAAC,IAAI,CAAC,IAAI;;;;;eAKf,MAAM,CAAC,IAAI;wCACc,MAAM,CAAC,IAAI,CAAC,IAAI;;CAEvD,CAAA;AACD,CAAC"}

package/dist/backend-database-prisma/generators/database-module.generator.d.ts

@@ -0,0 +1,2 @@
+import { DatabaseContext } from '../prisma.generator';
+export declare function generateDatabaseModule({ config, service, module }: DatabaseContext): string;

package/dist/backend-database-prisma/generators/database-module.generator.js

@@ -0,0 +1,66 @@
+"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.generateDatabaseModule = generateDatabaseModule;
+const Generator = __importStar(require("@postxl/generator"));
+function generateDatabaseModule({ config, service, module }) {
+    const imports = Generator.ImportGenerator
+        //
+        .from(module.moduleClass.location)
+        .add(config)
+        .add(service)
+        .addType(config.type);
+    return /* ts */ `
+import { DynamicModule } from '@nestjs/common'
+
+${imports.generate()}
+
+export class DatabaseModule {
+  static forRoot(config: ${config.type.name}): DynamicModule {
+    return {
+      module: ${module.moduleClass.name},
+      providers: [${service.name}, 
+        {
+          provide: ${config.name},
+          useFactory: () => new ${config.name}(config),
+        },
+      ],
+      exports: [${service.name}],
+      global: true,
+    }
+  }
+}`;
+}
+//# sourceMappingURL=database-module.generator.js.map

package/dist/backend-database-prisma/generators/database-module.generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"database-module.generator.js","sourceRoot":"","sources":["../../../src/backend-database-prisma/generators/database-module.generator.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA,wDA4BC;AAhCD,6DAA8C;AAI9C,SAAgB,sBAAsB,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAmB;IACjF,MAAM,OAAO,GAAG,SAAS,CAAC,eAAe;QACvC,EAAE;SACD,IAAI,CAAC,MAAM,CAAC,WAAY,CAAC,QAAQ,CAAC;SAClC,GAAG,CAAC,MAAM,CAAC;SACX,GAAG,CAAC,OAAO,CAAC;SACZ,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IAEvB,OAAO,QAAQ,CAAC;;;EAGhB,OAAO,CAAC,QAAQ,EAAE;;;2BAGO,MAAM,CAAC,IAAI,CAAC,IAAI;;gBAE3B,MAAM,CAAC,WAAY,CAAC,IAAI;oBACpB,OAAO,CAAC,IAAI;;qBAEX,MAAM,CAAC,IAAI;kCACE,MAAM,CAAC,IAAI;;;kBAG3B,OAAO,CAAC,IAAI;;;;EAI5B,CAAA;AACF,CAAC"}

package/dist/backend-database-prisma/generators/database-service.generator.d.ts

@@ -0,0 +1,2 @@
+import { DatabaseContext } from '../prisma.generator';
+export declare function generateDatabaseService({ service, config, prismaClient }: DatabaseContext): string;

package/dist/backend-database-prisma/generators/database-service.generator.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDatabaseService = generateDatabaseService;
+const generator_1 = require("@postxl/generator");
+function generateDatabaseService({ service, config, prismaClient }) {
+    const imports = generator_1.ImportGenerator
+        //
+        .from(service.location)
+        .add(prismaClient)
+        .add(config);
+    return /* ts */ `
+import { Injectable, Logger, OnModuleDestroy } from '@nestjs/common'
+import { Pool } from 'pg'
+import { PrismaPg } from '@prisma/adapter-pg'
+${imports.generate()}
+@Injectable()
+export class ${service.name} extends PrismaClient implements OnModuleDestroy {
+  private readonly logger = new Logger(${service.name}.name)
+  private readonly pool: Pool
+
+  constructor(config: ${config.name}) {
+    const pool = new Pool({ connectionString: config.config.connectionString })
+    const adapter = new PrismaPg(pool)
+
+    super({adapter})
+
+    this.pool = pool
+  }
+
+  public async onModuleDestroy() {
+    await this.$disconnect()
+    await this.pool.end()
+  }
+
+  // eslint-disable-next-line @typescript-eslint/require-await
+  public async emptyDatabase() {
+    this.logger.log('TODO: Implement Emptying database')
+    // TODO: Implement emptyDb!!!
+    // this.logger.log('Emptying database')
+    // await this.$executeRaw\`CALL empty_database();\`
+    // this.logger.log('Database emptied')
+  }
+}`;
+}
+//# sourceMappingURL=database-service.generator.js.map

package/dist/backend-database-prisma/generators/database-service.generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"database-service.generator.js","sourceRoot":"","sources":["../../../src/backend-database-prisma/generators/database-service.generator.ts"],"names":[],"mappings":";;AAIA,0DAwCC;AA5CD,iDAAmD;AAInD,SAAgB,uBAAuB,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,EAAmB;IACxF,MAAM,OAAO,GAAG,2BAAe;QAC7B,EAAE;SACD,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC;SACtB,GAAG,CAAC,YAAY,CAAC;SACjB,GAAG,CAAC,MAAM,CAAC,CAAA;IAEd,OAAO,QAAQ,CAAC;;;;EAIhB,OAAO,CAAC,QAAQ,EAAE;;eAEL,OAAO,CAAC,IAAI;yCACc,OAAO,CAAC,IAAI;;;wBAG7B,MAAM,CAAC,IAAI;;;;;;;;;;;;;;;;;;;;;;EAsBjC,CAAA;AACF,CAAC"}

package/dist/backend-database-prisma/generators/index.generator.d.ts

@@ -0,0 +1,2 @@
+import { DatabaseContext } from '../prisma.generator';
+export declare function generatePrismaIndex(context: DatabaseContext): string;

package/dist/backend-database-prisma/generators/index.generator.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePrismaIndex = generatePrismaIndex;
+function generatePrismaIndex(context) {
+    return /* ts */ `
+import type { Prisma } from '${context.prismaClient.location}'
+// We re-export the Prisma types to make them available to the apps using this library
+export * from '${context.prismaClient.location}'
+export type Decimal = Prisma.Decimal
+`;
+}
+//# sourceMappingURL=index.generator.js.map

package/dist/backend-database-prisma/generators/index.generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.generator.js","sourceRoot":"","sources":["../../../src/backend-database-prisma/generators/index.generator.ts"],"names":[],"mappings":";;AAEA,kDAOC;AAPD,SAAgB,mBAAmB,CAAC,OAAwB;IAC1D,OAAO,QAAQ,CAAC;+BACa,OAAO,CAAC,YAAY,CAAC,QAAQ;;iBAE3C,OAAO,CAAC,YAAY,CAAC,QAAQ;;CAE7C,CAAA;AACD,CAAC"}

package/dist/backend-database-prisma/generators/prisma-schema.generator.d.ts

@@ -0,0 +1,2 @@
+import { ContextResult } from '../prisma.generator';
+export declare function generatePrismaSchema(context: ContextResult): string;

package/dist/backend-database-prisma/generators/prisma-schema.generator.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePrismaSchema = generatePrismaSchema;
+const generator_1 = require("@postxl/generator");
+const utils_1 = require("@postxl/utils");
+const prisma_utils_1 = require("../prisma.utils");
+function generatePrismaSchema(context) {
+    const schemas = new Map();
+    for (const model of context.models.values()) {
+        const schema = schemas.get(model.databaseSchema) || [];
+        if (schema.length === 0) {
+            schema.push(createSchemaHeader(model.databaseSchema));
+        }
+        schema.push(createPrismaModel({ model, models: context.models }));
+        schemas.set(model.databaseSchema, schema);
+    }
+    for (const enumType of context.enums.values()) {
+        const schema = schemas.get(enumType.databaseSchema) || [];
+        if (schema.length === 0) {
+            schema.push(createSchemaHeader(enumType.databaseSchema));
+        }
+        schema.push(createPrismaEnum(enumType));
+        schemas.set(enumType.databaseSchema, schema);
+    }
+    const result = /**prisma */ `
+    datasource db {
+      provider = "postgres"
+      url      = env("DATABASE_CONNECTION")
+      schemas  = [${Array.from(schemas.keys())
+        .map((schema) => `"${(0, utils_1.toSnakeCase)(schema)}"`)
+        .join(', ')}]
+    }
+
+    generator client {
+      provider        = "prisma-client"
+      output   = "./prisma"
+      engineType = "client"
+    }
+
+  ${Array.from(schemas.values())
+        .map((schema) => schema.join('\n'))
+        .join('\n')}`;
+    // return result
+    const formatted = (0, prisma_utils_1.formatPrismaSchema)(result);
+    const linterResult = (0, prisma_utils_1.lintPrismaSchema)(formatted);
+    if (linterResult.isErr()) {
+        const error = linterResult.unwrapErr();
+        console.error(error);
+        if (!context.options.ignoreErrors) {
+            throw new Error(`Prisma schema is invalid: ${error.join('\n')}`);
+        }
+    }
+    return formatted;
+}
+function createSchemaHeader(schema) {
+    return (0, generator_1.ts)(`
+  // # --------------------------- #
+  // # ${schema} Schema #
+  // # --------------------------- #`);
+}
+function createPrismaModel({ model, models, }) {
+    const fields = [];
+    for (const field of model.fields.values()) {
+        fields.push(createPrismaField({ field, models }));
+    }
+    const backReferences = createModelBackReferences({ model, models });
+    return (0, generator_1.ts)(`
+model ${model.name} {
+${fields.join('\n')}
+
+${backReferences}
+  @@map("${model.databaseName}")
+  @@schema("${(0, utils_1.toSnakeCase)(model.databaseSchema)}")
+}`);
+}
+function createPrismaField({ field, models, }) {
+    switch (field.kind) {
+        case 'id':
+            return `${field.name} ${field.databaseType} @id @default(cuid())${description(field)}${mapField(field)}\n`;
+        case 'scalar':
+            return createScalarField(field);
+        case 'relation':
+            return createRelationField(field);
+        case 'enum':
+            return createEnumField(field);
+        case 'discriminatedUnion':
+            return createDiscriminatedUnionField({ field, models });
+        default:
+            throw new utils_1.ExhaustiveSwitchCheck(field);
+    }
+}
+function createScalarField(field) {
+    return `${field.databaseName} ${field.databaseType}${fieldAttributes(field)}`;
+}
+function createRelationField(field) {
+    return `
+      ${field.databaseName} ${field.databaseType}${fieldAttributes(field)}
+      ${removeId(field.databaseName)} ${field.referencedModelName}${isRequired(field)} @relation("${relationName(field)}", fields: [${field.databaseName}], references: [id])
+    `;
+}
+function createDiscriminatedUnionField({ field, models, }) {
+    const elements = [];
+    // Discriminant field
+    elements.push(`
+    /// -- Discriminated union definition for ${field.name}
+
+    /// Discriminant field
+    /// Values can be: ${Array.from(field.members.keys()).join(', ')}
+    ${field.name} ${field.databaseType}${fieldAttributes(field)}
+    `);
+    if (field.commonFields.size > 0) {
+        elements.push(` /// -- Shared fields`);
+    }
+    for (const sharedField of field.commonFields.values()) {
+        elements.push(createPrismaField({ field: sharedField, models }));
+    }
+    for (const member of field.members.values()) {
+        elements.push(` /// -- Member ${member.type}`);
+        for (const memberField of member.fields.values()) {
+            elements.push(createPrismaField({
+                field: {
+                    ...memberField,
+                    //even if the field is required, we need to make it optional in the database as it will be null in case the item is not of this type
+                    isRequired: false,
+                },
+                models,
+            }));
+        }
+    }
+    elements.push(` /// -- Discriminated union ${field.name} end`);
+    return elements.join('\n');
+}
+function fieldAttributes(field) {
+    const attributes = [];
+    const add = (condition, attribute) => {
+        if (condition) {
+            attributes.push(attribute);
+        }
+    };
+    add(!field.isRequired, '?');
+    add(field.isUnique, '@unique');
+    add(field.name !== field.databaseName, `@map("${field.databaseName}")`);
+    add(field.kind === 'scalar' && field.isCreatedAt, '@default(now())');
+    add(field.kind === 'scalar' && field.isUpdatedAt, '@updatedAt');
+    add(field.description !== undefined, description(field));
+    return attributes.join(' ');
+}
+function createEnumField(field) {
+    return `${field.databaseName} ${field.enumName}${fieldAttributes(field)}`;
+}
+function isRequired({ isRequired }) {
+    return isRequired ? '' : '?'; // NOSONAR
+}
+function description({ description }) {
+    return description
+        ? description
+            .split('\n')
+            .map((d) => `  /// ${d}`)
+            .join('\n')
+        : '';
+}
+function mapField(field) {
+    if (field.name === field.databaseName) {
+        return '';
+    }
+    return `@map("${field.databaseName}")`;
+}
+function relationName(field) {
+    return `${field.modelName}.${field.name}->${field.referencedModelName}`;
+}
+function createPrismaEnum(enum_) {
+    const members = [];
+    for (const member of enum_.members.values()) {
+        members.push(`  ${member.value}`);
+    }
+    return (0, generator_1.ts)(`
+enum ${enum_.name} {
+${members.join('\n')}
+  @@map("${enum_.databaseName}")
+  @@schema("${(0, utils_1.toSnakeCase)(enum_.databaseSchema)}")
+}`);
+}
+function createModelBackReferences({ model, models, }) {
+    const backReferences = [];
+    for (const targetModel of models.values()) {
+        backReferences.push(...createModelBackReferencesFromFields({
+            model,
+            targetModel,
+            fields: Array.from(targetModel.fields.values()),
+        }));
+    }
+    if (backReferences.length === 0) {
+        return '';
+    }
+    return `/// Back references to ${model.name}
+  ${backReferences.join('\n')}`;
+}
+function createModelBackReferencesFromFields({ model, targetModel, fields, }) {
+    const backReferences = [];
+    for (const field of fields.values()) {
+        if (field.kind === 'relation' && field.referencedModelName === model.name) {
+            backReferences.push(`${(0, utils_1.toCamelCase)(targetModel.name)}${(0, utils_1.toPascalCase)((0, utils_1.pluralize)(removeId(field.name)))} ${targetModel.name}[] @relation("${relationName(field)}")`);
+        }
+        if (field.kind === 'discriminatedUnion') {
+            backReferences.push(...createModelBackReferencesFromFields({
+                model,
+                targetModel,
+                fields: Array.from(field.commonFields.values()),
+            }));
+            for (const member of field.members.values()) {
+                backReferences.push(...createModelBackReferencesFromFields({
+                    model,
+                    targetModel,
+                    fields: Array.from(member.fields.values()),
+                }));
+            }
+        }
+    }
+    return backReferences;
+}
+function removeId(name) {
+    return name.replace(/_id$/, '');
+}
+//# sourceMappingURL=prisma-schema.generator.js.map