@solidstarters/solid-core 1.2.73 → 1.2.76

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidstarters/solid-core",
-  "version": "1.2.73",
+  "version": "1.2.76",
   "description": "This module is a NestJS module containing all the required core providers required by a Solid application",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -44,6 +44,8 @@
     "cache-manager-redis-store": "^3.0.1",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.14.1",
+    "exceljs": "^4.4.0",
+    "fast-csv": "^5.0.2",
     "handlebars": "^4.7.8",
     "ioredis": "^5.4.1",
     "lodash": "^4.17.21",

package/src/controllers/export-template.controller.ts

@@ -0,0 +1,98 @@
+import { Controller, Post, Body, Param, UploadedFiles, UseInterceptors, Put, Get, Query, Delete, Patch, Res, InternalServerErrorException } from '@nestjs/common';
+import { AnyFilesInterceptor } from "@nestjs/platform-express";
+import { ApiBearerAuth, ApiQuery, ApiTags } from '@nestjs/swagger';
+import { ExportTemplateService } from '../services/export-template.service';
+import { CreateExportTemplateDto } from '../dtos/create-export-template.dto';
+import { UpdateExportTemplateDto } from '../dtos/update-export-template.dto';
+import { Response } from 'express';
+
+@ApiTags('Solid') 
+@Controller('export-template') //FIXME: Change this to the model plural name 
+export class ExportTemplateController { 
+  constructor(private readonly service: ExportTemplateService) {}
+
+  @ApiBearerAuth("jwt")
+  @Post()
+  @UseInterceptors(AnyFilesInterceptor())
+  create(@Body() createDto: CreateExportTemplateDto, @UploadedFiles() files: Array<Express.Multer.File>) {
+    return this.service.create(createDto, files);
+  }
+
+  @ApiBearerAuth("jwt")
+  @Post('/bulk')
+  @UseInterceptors(AnyFilesInterceptor())
+  insertMany(@Body() createDtos: CreateExportTemplateDto[], @UploadedFiles() filesArray: Express.Multer.File[][] = []) {
+    return this.service.insertMany(createDtos, filesArray);
+  }
+
+
+  @ApiBearerAuth("jwt")
+  @Put(':id')
+  @UseInterceptors(AnyFilesInterceptor())
+  update(@Param('id') id: number, @Body() updateDto: UpdateExportTemplateDto, @UploadedFiles() files: Array<Express.Multer.File>) {
+    return this.service.update(id, updateDto, files);
+  }
+
+  @ApiBearerAuth("jwt")
+  @Patch(':id')
+  @UseInterceptors(AnyFilesInterceptor())
+  partialUpdate(@Param('id') id: number, @Body() updateDto: UpdateExportTemplateDto, @UploadedFiles() files: Array<Express.Multer.File>) {
+    return this.service.update(id, updateDto, files, true);
+  }
+    
+  @ApiBearerAuth("jwt")
+  @ApiQuery({ name: 'showSoftDeleted', required: false, type: Boolean })
+  @ApiQuery({ name: 'showOnlySoftDeleted', required: false, type: Boolean })
+  @ApiQuery({ name: 'limit', required: false, type: Number })
+  @ApiQuery({ name: 'offset', required: false, type: Number })
+  @ApiQuery({ name: 'fields', required: false, type: Array })
+  @ApiQuery({ name: 'sort', required: false, type: Array }) 
+  @ApiQuery({ name: 'groupBy', required: false, type: Array })
+  @ApiQuery({ name: 'populate', required: false, type: Array })
+  @ApiQuery({ name: 'populateMedia', required: false, type: Array })
+  @ApiQuery({ name: 'filters', required: false, type: Array })
+  @Get()
+  async findMany(@Query() query: any) { 
+    return this.service.find(query);  
+  }
+
+  @ApiBearerAuth("jwt")
+  @Get(':id')
+  async findOne(@Param('id') id: string, @Query() query: any) {
+    return this.service.findOne(+id, query);
+  }
+
+  @Delete('/bulk')
+  async deleteMany(@Body() ids: number[]) {
+    return this.service.deleteMany(ids);
+  }
+
+  @ApiBearerAuth("jwt")
+  @Delete(':id')
+  async delete(@Param('id') id: number) {
+    return this.service.delete(id);
+  }
+
+  @ApiBearerAuth("jwt")
+  @Post(':id/startExport/sync')
+  async startExportSync(@Param('id') id: number, @Res() res: Response) {
+    const exportFileInfo = await this.service.startExportSync(+id);
+    if (exportFileInfo.exportStream === null) {
+      throw new InternalServerErrorException("Export stream is null");
+    }
+
+    // ✅ Set response headers for streaming
+    res.setHeader('Content-Disposition', `attachment; filename="${exportFileInfo.fileName}"`);
+    res.setHeader('Content-Type', exportFileInfo.mimeType);
+    res.setHeader('Access-Control-Expose-Headers', 'Content-Disposition, Content-Type');
+    // Pipe the strea to the response as an excel file
+    exportFileInfo.exportStream.pipe(res);
+  }
+
+  @ApiBearerAuth("jwt")
+  @Post(':id/startExport/async')
+  async startExportAsync(@Param('id') id: number) {
+    return this.service.startExportAsync(+id);
+  }
+
+}

package/src/controllers/export-transaction.controller.ts

@@ -0,0 +1,76 @@
+import { Controller, Post, Body, Param, UploadedFiles, UseInterceptors, Put, Get, Query, Delete, Patch } from '@nestjs/common';
+import { AnyFilesInterceptor } from "@nestjs/platform-express";
+import { ApiBearerAuth, ApiQuery, ApiTags } from '@nestjs/swagger';
+import { ExportTransactionService } from '../services/export-transaction.service';
+import { CreateExportTransactionDto } from '../dtos/create-export-transaction.dto';
+import { UpdateExportTransactionDto } from '../dtos/update-export-transaction.dto';
+
+@ApiTags('Solid') 
+@Controller('export-transaction') //FIXME: Change this to the model plural name 
+export class ExportTransactionController {
+  constructor(private readonly service: ExportTransactionService) {}
+
+  @ApiBearerAuth("jwt")
+  @Post()
+  @UseInterceptors(AnyFilesInterceptor())
+  create(@Body() createDto: CreateExportTransactionDto, @UploadedFiles() files: Array<Express.Multer.File>) {
+    return this.service.create(createDto, files);
+  }
+
+  @ApiBearerAuth("jwt")
+  @Post('/bulk')
+  @UseInterceptors(AnyFilesInterceptor())
+  insertMany(@Body() createDtos: CreateExportTransactionDto[], @UploadedFiles() filesArray: Express.Multer.File[][] = []) {
+    return this.service.insertMany(createDtos, filesArray);
+  }
+
+
+  @ApiBearerAuth("jwt")
+  @Put(':id')
+  @UseInterceptors(AnyFilesInterceptor())
+  update(@Param('id') id: number, @Body() updateDto: UpdateExportTransactionDto, @UploadedFiles() files: Array<Express.Multer.File>) {
+    return this.service.update(id, updateDto, files);
+  }
+
+  @ApiBearerAuth("jwt")
+  @Patch(':id')
+  @UseInterceptors(AnyFilesInterceptor())
+  partialUpdate(@Param('id') id: number, @Body() updateDto: UpdateExportTransactionDto, @UploadedFiles() files: Array<Express.Multer.File>) {
+    return this.service.update(id, updateDto, files, true);
+  }
+    
+  @ApiBearerAuth("jwt")
+  @ApiQuery({ name: 'showSoftDeleted', required: false, type: Boolean })
+  @ApiQuery({ name: 'showOnlySoftDeleted', required: false, type: Boolean })
+  @ApiQuery({ name: 'limit', required: false, type: Number })
+  @ApiQuery({ name: 'offset', required: false, type: Number })
+  @ApiQuery({ name: 'fields', required: false, type: Array })
+  @ApiQuery({ name: 'sort', required: false, type: Array }) 
+  @ApiQuery({ name: 'groupBy', required: false, type: Array })
+  @ApiQuery({ name: 'populate', required: false, type: Array })
+  @ApiQuery({ name: 'populateMedia', required: false, type: Array })
+  @ApiQuery({ name: 'filters', required: false, type: Array })
+  @Get()
+  async findMany(@Query() query: any) { 
+    return this.service.find(query);  
+  }
+
+  @ApiBearerAuth("jwt")
+  @Get(':id')
+  async findOne(@Param('id') id: string, @Query() query: any) {
+    return this.service.findOne(+id, query);
+  }
+
+  @Delete('/bulk')
+  async deleteMany(@Body() ids: number[]) {
+    return this.service.deleteMany(ids);
+  }
+
+  @ApiBearerAuth("jwt")
+  @Delete(':id')
+  async delete(@Param('id') id: number) {
+    return this.service.delete(id);
+  }
+
+
+}

package/src/dtos/create-export-template.dto.ts

@@ -0,0 +1,27 @@
+import { IsString } from 'class-validator';
+import { IsNotEmpty, IsBoolean, IsOptional, IsInt, IsJSON } from 'class-validator';
+export class CreateExportTemplateDto {
+@IsNotEmpty()
+@IsString()
+templateName: string;
+
+@IsNotEmpty()
+@IsString()
+templateFormat: string;
+
+@IsOptional()
+@IsBoolean()
+notifyOnEmail: boolean = true;
+
+@IsNotEmpty()
+@IsJSON()
+fields: any;
+
+@IsOptional()
+@IsInt()
+modelMetadataId: number;
+
+@IsString()
+@IsOptional()
+modelMetadataUserKey: string;
+}

package/src/dtos/create-export-transaction.dto.ts

@@ -0,0 +1,26 @@
+import { IsDate } from 'class-validator';
+import { IsNotEmpty, IsString, IsOptional, IsInt } from 'class-validator';
+export class CreateExportTransactionDto {
+constructor(data: Partial<CreateExportTransactionDto>) {
+    Object.assign(this, data);
+}    
+@IsNotEmpty()
+@IsDate()
+datetime: Date;
+
+@IsNotEmpty()
+@IsString()
+status: string;
+
+@IsOptional()
+@IsString()
+error: string;
+
+@IsOptional()
+@IsInt()
+exportTemplateId: number;
+
+@IsString()
+@IsOptional()
+exportTemplateUserKey: string;
+}

package/src/dtos/update-export-template.dto.ts

@@ -0,0 +1,33 @@
+import { IsInt,IsOptional, IsString, IsNotEmpty, IsBoolean, IsJSON } from 'class-validator';
+export class UpdateExportTemplateDto {
+    @IsOptional()
+    @IsInt()
+    id: number;
+
+@IsNotEmpty()
+@IsOptional()
+@IsString()
+templateName: string;
+
+@IsNotEmpty()
+@IsOptional()
+@IsString()
+templateFormat: string;
+
+@IsOptional()
+@IsBoolean()
+notifyOnEmail: boolean = true;
+
+@IsNotEmpty()
+@IsOptional()
+@IsJSON()
+fields: any;
+
+@IsOptional()
+@IsInt()
+modelMetadataId: number;
+
+@IsString()
+@IsOptional()
+modelMetadataUserKey: string;
+}

package/src/dtos/update-export-transaction.dto.ts

@@ -0,0 +1,28 @@
+import { IsInt,IsOptional, IsDate, IsNotEmpty, IsString } from 'class-validator';
+export class UpdateExportTransactionDto {
+    @IsOptional()
+    @IsInt()
+    id: number;
+
+@IsNotEmpty()
+@IsOptional()
+@IsDate()
+datetime: Date;
+
+@IsNotEmpty()
+@IsOptional()
+@IsString()
+status: string;
+
+@IsOptional()
+@IsString()
+error: string;
+
+@IsOptional()
+@IsInt()
+exportTemplateId: number;
+
+@IsString()
+@IsOptional()
+exportTemplateUserKey: string;
+}

package/src/entities/export-template.entity.ts

@@ -0,0 +1,20 @@
+import { CommonEntity } from 'src/entities/common.entity'
+import { Entity, Column, Index, ManyToOne } from 'typeorm';
+import { ModelMetadata } from 'src/entities/model-metadata.entity'
+
+@Entity("ss_export_template")
+@Index(["templateName", "deletedTracker"], { unique: true })
+export class ExportTemplate extends CommonEntity {
+    @Index()
+    @Column({ type: "varchar" })
+    templateName: string;
+    @Column({ type: "varchar" })
+    templateFormat: string;
+    @Column({ type: "boolean", nullable: true, default: true })
+    notifyOnEmail: boolean = true;
+    @Column({ type: "varchar" })
+    fields: any;
+    @Index()
+    @ManyToOne(() => ModelMetadata, { onDelete: "CASCADE", nullable: false })
+    modelMetadata: ModelMetadata;
+}

package/src/entities/export-transaction.entity.ts

@@ -0,0 +1,22 @@
+import { CommonEntity } from 'src/entities/common.entity'
+import { Entity, Column, Index, ManyToOne } from 'typeorm';
+import { ExportTemplate } from 'src/entities/export-template.entity'
+
+@Entity("ss_export_transaction")
+@Index(["exportTransactionId", "deletedTracker"], { unique: true })
+export class ExportTransaction extends CommonEntity {
+    @Index()
+    @Column({ type: "timestamp" })
+    datetime: Date;
+    @Index()
+    @Column({ type: "varchar" })
+    exportTransactionId: string;
+    @Index()
+    @Column({ type: "varchar" })
+    status: string;
+    @Column({ type: "text", nullable: true })
+    error: string;
+    @Index()
+    @ManyToOne(() => ExportTemplate, { onDelete: "CASCADE", nullable: false })
+    exportTemplate: ExportTemplate;
+}

package/src/index.ts

@@ -111,6 +111,8 @@ export * from './entities/security-rule.entity'
 export * from './entities/saved-filters.entity'
 export * from './entities/chatter-message.entity'
 export * from './entities/chatter-message-details.entity'
+export * from './entities/export-template.entity'
+export * from './entities/export-transaction.entity'
 
 export * from './enums/auth-type.enum'
 

package/src/interfaces.ts

@@ -11,6 +11,7 @@ import { CreateSecurityRuleDto } from './dtos/create-security-rule.dto';
 import { CreateViewMetadataDto } from './dtos/create-view-metadata.dto';
 import { FieldMetadata } from './entities/field-metadata.entity';
 import { Media } from './entities/media.entity';
+import { Readable } from 'stream';
 
 export interface FieldCrudManager {
   // fieldMetadata: FieldMetadata;
@@ -34,6 +35,7 @@ export interface MediaStorageProvider<T> {
     store(files: Express.Multer.File[], entity: T, mediaFieldMetadata: FieldMetadata): Promise<Media[]>;
     delete(entity: T, mediaFieldMetadata: FieldMetadata): Promise<void>;
     retrieve(entity: T, mediaFieldMetadata: FieldMetadata): Promise<Media[]>;
+    storeStreams(streamPairs: [Readable, string][], entity: T, mediaFieldMetadata: FieldMetadata): Promise<Media[]>;
     // delete(file: string): Promise<void>;
 }
 

package/src/seeders/module-metadata-seeder.service.ts

@@ -72,7 +72,7 @@ export class ModuleMetadataSeederService {
 
     async seed() {
 
-        const typedSolidCoreMetadata: any = solidCoreMetadata;
+        const typedSolidCoreMetadata: any = structuredClone(solidCoreMetadata);
 
         // Run the permissions seeder. 
         // await this.permissionsSeederService.seed();

package/src/seeders/seed-data/solid-core-metadata.json

@@ -2828,7 +2828,7 @@
             "private": false,
             "encrypt": false,
             "relationType": "many-to-one",
-            "relationModelSingularName": "emailTemplate",
+            "relationCoModelSingularName": "emailTemplate",
             "relationCreateInverse": false,
             "relationCascade": "cascade",
             "relationTypeManyToManyOwner": true,
@@ -3395,6 +3395,188 @@
             "isRelationManyToManyOwner": null
           }
         ]
+      },
+      {
+        "singularName": "exportTemplate",
+        "tableName": "ss_export_template",
+        "pluralName": "exportTemplates",
+        "displayName": "Export Templates",
+        "description": "Model to capture all information related to an file export template",
+        "dataSource": "default",
+        "dataSourceType": "postgres",
+        "isSystem": true,
+        "userKeyFieldUserKey": "templateName",
+        "fields": [
+          {
+            "name": "templateName",
+            "displayName": "Template Name",
+            "type": "shortText",
+            "ormType": "varchar",
+            "length": 256,
+            "required": true,
+            "unique": true,  
+            "index": true,
+            "private": false,
+            "encrypt": false,
+            "isSystem": true
+          },
+          {
+            "name": "templateFormat",
+            "displayName": "Template Format",
+            "type": "selectionStatic",
+            "ormType": "varchar",
+            "length": 25,
+            "required": true,
+            "index": false,
+            "isSystem": true,
+            "selectionValueType": "string",
+            "selectionStaticValues": [
+              "csv:csv",
+              "excel:excel"
+            ]
+          },
+          {
+            "name": "notifyOnEmail",
+            "displayName": "Notify On Email",
+            "type": "boolean",
+            "ormType": "boolean",
+            "defaultValue": "false",
+            "required": false,
+            "unique": false,
+            "index": false,
+            "private": false,
+            "encrypt": false,
+            "isSystem": true
+          },
+          {
+            "name": "modelMetadata",
+            "displayName": "Related Model Metadata",
+            "type": "relation",
+            "ormType": "int",
+            "required": true,
+            "unique": false,
+            "index": true,
+            "private": false,
+            "encrypt": false,
+            "relationType": "many-to-one",
+            "relationCoModelSingularName": "modelMetadata",
+            "relationCreateInverse": false,
+            "relationCascade": "cascade",
+            "relationModelModuleName": "solid-core",
+            "isSystem": true
+          },
+          {
+            "name": "fields",
+            "displayName": "Fields",
+            "type": "json",
+            "ormType": "varchar",
+            "length": 2056,
+            "required": true,
+            "unique": false,
+            "index": false,
+            "private": false,
+            "encrypt": false,
+            "isSystem": true
+          }
+        ]
+      },
+      {
+        "singularName": "exportTransaction",
+        "tableName": "ss_export_transaction",
+        "pluralName": "exportTransactions",
+        "displayName": "Export Transactions",
+        "description": "Model to capture all information related to a file export transaction",
+        "dataSource": "default",
+        "dataSourceType": "postgres",
+        "isSystem": true,
+        "userKeyFieldUserKey": "exportTransactionId",
+        "fields": [
+          {
+            "name": "datetime",
+            "displayName": "Transaction Date Time",
+            "type": "datetime",
+            "ormType": "timestamp",
+            "required": true,
+            "unique": false,
+            "index": true,
+            "private": false,
+            "encrypt": false,
+            "isSystem": true
+          },
+          {
+            "name": "exportTransactionId",
+            "displayName": "Transaction Id",
+            "type":"computed",
+            "ormType": "varchar",
+            "length": 128,
+            "required": true,
+            "unique": true,
+            "index": true,
+            "private": false,
+            "encrypt": false,
+            "isSystem": true,
+            "computedFieldValueType": "string",
+            "computedFieldValueProvider": "UuidExternalIdComputedFieldProvider",
+            "computedFieldValueProviderCtxt": "{\"prefix\": \"export_transaction\"}"
+          },
+          {
+            "name": "status",
+            "displayName": "Status",
+            "type": "selectionStatic",
+            "ormType": "varchar",
+            "length": 25,
+            "required": true,
+            "index": true,
+            "isSystem": true,
+            "selectionValueType": "string",
+            "selectionStaticValues": [
+              "started:started",
+              "failed:failed",
+              "finished:finished"
+            ]
+          },
+          {
+            "name": "exportedFile",
+            "displayName": "Exported File",
+            "type": "mediaSingle",
+            "required": false,
+            "unique": true,
+            "index": false,
+            "private": false,
+            "encrypt": false,
+            "isSystem": true,
+            "mediaStorageProviderUserKey": "default-filesystem"
+          },
+          {
+            "name": "error",
+            "displayName": "Error",
+            "type": "longText",
+            "ormType": "text",
+            "required": false,
+            "unique": false,
+            "index": false,
+            "private": false,
+            "encrypt": false,
+            "isSystem": true
+          },
+          {
+            "name": "exportTemplate",
+            "displayName": "Related Export Template",
+            "type": "relation",
+            "ormType": "int",
+            "required": true,
+            "unique": false,
+            "index": true,
+            "private": false,
+            "encrypt": false,
+            "relationType": "many-to-one",
+            "relationCoModelSingularName": "exportTemplate",
+            "relationCreateInverse": false,
+            "relationCascade": "cascade",
+            "relationModelModuleName": "solid-core",
+            "isSystem": true
+          }
+        ]
       }
     ]
   },

package/src/services/csv.service.ts

@@ -0,0 +1,41 @@
+import { PassThrough, Readable } from 'stream';
+import { format } from 'fast-csv';
+import { Injectable, Logger } from '@nestjs/common';
+
+@Injectable()
+export class CsvService {
+  private logger = new Logger(CsvService.name);
+  public async createCsvStream(
+    getDataRecords: (chunkIndex: number, chunkSize: number) => Promise<any[]>,
+    chunkSize: number
+  ): Promise<Readable> {
+    const passThrough = new PassThrough(); // ✅ Create a streaming pipe
+    const csvStream = format({ headers: true });
+
+    csvStream.pipe(passThrough); // ✅ Pipe CSV output to PassThrough stream
+
+    let chunkIndex = 0;
+
+    try {
+      while (true) {
+        const records = await getDataRecords(chunkIndex, chunkSize); // ✅ Fetch chunked data
+        if (records.length === 0) break; // ✅ Stop if no more records
+
+        for (const record of records) {
+          csvStream.write(record); // ✅ Write each record to the CSV stream
+        }
+
+        chunkIndex++; // ✅ Fetch next chunk
+        this.logger.debug(`✅ Chunk ${chunkIndex} written to CSV`);
+      }
+
+      csvStream.end(); // ✅ Ensure CSV stream is finalized
+    } catch (error) {
+      this.logger.error(`❌ Error writing CSV: ${error.message}`);
+      passThrough.destroy(error); // ✅ Properly destroy stream on error
+      throw error;
+    }
+
+    return passThrough; // ✅ Return the streaming response
+  }
+}