@solidstarters/solid-core 1.2.206 → 1.2.207

package/docs/type-declaration-import-issue.md

@@ -0,0 +1,24 @@
+# Issue: Consumer sees `Property 'id' does not exist on type 'VenueUser'`
+
+## Summary
+The published declaration files in `dist/` import internal types using `src/...` module specifiers. In a consuming project, TypeScript resolves those imports against the consumer's `src` path (or fails), which can cause `User` to extend a different `CommonEntity` that does not define `id`. This leads to `Property 'id' does not exist on type 'VenueUser'` even though `CommonEntity` in the library defines it.
+
+## Evidence
+- `dist/entities/user.entity.d.ts` starts with:
+  - `import { CommonEntity } from "src/entities/common.entity";`
+- `dist/entities/common.entity.d.ts` correctly contains:
+  - `id: number;`
+
+Because the import is `src/...`, the consumer may resolve it to their own `src` tree instead of the library's `dist` types.
+
+## Root Cause
+Library declarations are not portable because internal imports are using absolute `src/...` aliases. These aliases are not part of Node module resolution, so consumers resolve them differently.
+
+## Fix Options
+1. **Preferred:** Replace internal imports in `src/` with relative paths so emitted `.d.ts` files are portable.
+2. **Alternative:** Keep `src/*` aliases but add a post-build step (e.g., `tsc-alias`) to rewrite `dist/**/*.d.ts` imports to relative paths.
+
+## Next Steps
+- Decide on option 1 or 2.
+- Rebuild and verify `dist/**/*.d.ts` no longer import from `src/...`.
+- Publish a new package version and ensure the consuming app resolves `User` and `CommonEntity` from the same package instance.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidstarters/solid-core",
-  "version": "1.2.206",
+  "version": "1.2.207",
   "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",
@@ -49,6 +49,7 @@
     "cache-manager-redis-store": "^3.0.1",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.14.1",
+    "cron-parser": "^5.5.0",
     "dayjs": "^1.11.18",
     "exceljs": "^4.4.0",
     "fast-csv": "^5.0.2",

package/src/commands/seed.command.ts

@@ -42,7 +42,7 @@ export class SeedCommand extends CommandRunner {
       this.logger.error(`Seeder service ${options.seeder} not found. Does your service have a seed() method?`);
       return;
     }
-    this.logger.log(`Running the seed() method for seeder :${seeder.constructor.name}`);
+    this.logger.log(`Running the seed() method for seeder: ${seeder.constructor.name}`);
     await seeder.seed(parsedConf);
   }
 

package/src/controllers/test.controller.ts

@@ -44,22 +44,4 @@ export class TestController {
     await this.ingestMetadataService.ingest();
     return { ok: true };
   }
-
-  // @Public()
-  // @Post('seed')
-  // async seedData(@Body() seedData: any) {
-  //   const seeder = this.solidRegistry
-  //     .getSeeders()
-  //     .filter((seeder) => seeder.name === seedData.seeder)
-  //     .map((seeder) => seeder.instance)
-  //     .pop();
-  //   if (!seeder) {
-  //     this.logger.error(`Seeder service ${seedData.seeder} not found. Does your service have a seed() method?`);
-  //     return;
-  //   }
-  //   this.logger.log(`Running the seed() method for seeder :${seeder.constructor.name}`);
-  //   await seeder.seed();
-  //   return { message: `seed data for ${seedData.seeder}` };
-  // }
-
 }

package/src/dtos/create-scheduled-job.dto.ts

@@ -52,6 +52,10 @@ export class CreateScheduledJobDto {
     @ApiProperty()
     job: string;
     @IsOptional()
+    @IsString()
+    @ApiProperty()
+    cronExpression: string;
+    @IsOptional()
     @IsInt()
     @ApiProperty()
     moduleId: number;

package/src/dtos/update-scheduled-job.dto.ts

@@ -58,6 +58,10 @@ export class UpdateScheduledJobDto {
     @ApiProperty()
     job: string;
     @IsOptional()
+    @IsString()
+    @ApiProperty()
+    cronExpression: string;
+    @IsOptional()
     @IsInt()
     @ApiProperty()
     moduleId: number;

package/src/entities/scheduled-job.entity.ts

@@ -29,6 +29,8 @@ export class ScheduledJob extends CommonEntity {
     dayOfWeek: string;
     @Column({ type: "varchar" })
     job: string;
+    @Column({ type: "varchar", nullable: true })
+    cronExpression: string;
     @Index()
     @ManyToOne(() => ModuleMetadata, { nullable: false })
     @JoinColumn({ referencedColumnName: 'id' })

package/src/helpers/command.service.ts

@@ -1,22 +1,54 @@
 import { Injectable, Logger } from '@nestjs/common';
-import { exec } from 'child_process';
+import { spawn } from 'child_process';
+
+export type CommandWithArgs = {
+  command: string;
+  args: string[];
+};
 
 @Injectable()
 export class CommandService {
   private readonly logger = new Logger(CommandService.name);
 
-  async executeCommand(command: string): Promise<string> {
-    this.logger.debug(`Executing command :${command}`);
+  /**
+   * Execute a command with arguments array (cross-platform compatible)
+   */
+  async executeCommandWithArgs(commandWithArgs: CommandWithArgs): Promise<string> {
+    const { command, args } = commandWithArgs;
+    this.logger.debug(`Executing command: ${command} ${args.join(' ')}`);
+
     return new Promise<string>((resolve, reject) => {
-      exec(command, (error, stdout, stderr) => {
-        if (error) {
-          this.logger.error(`Error executing command :${command}`, error);
-          reject(error);
-          return;
-        }
-        if (stderr) {
-          this.logger.error(`Error executing command :${command}`, stderr);
-          reject(stderr);
+      const isWindows = process.platform === 'win32';
+
+      // On Windows, we need to use cmd /c for commands that might be .cmd files (like npm scripts)
+      const spawnCommand = isWindows ? command : command;
+      const spawnArgs = args;
+
+      const child = spawn(spawnCommand, spawnArgs, {
+        shell: isWindows, // Use shell on Windows to handle .cmd files
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+
+      let stdout = '';
+      let stderr = '';
+
+      child.stdout.on('data', (data) => {
+        stdout += data.toString();
+      });
+
+      child.stderr.on('data', (data) => {
+        stderr += data.toString();
+      });
+
+      child.on('error', (error) => {
+        this.logger.error(`Error executing command: ${command}`, error);
+        reject(error);
+      });
+
+      child.on('close', (code) => {
+        if (code !== 0) {
+          this.logger.error(`Command failed with code ${code}: ${command}`, stderr);
+          reject(new Error(stderr || `Command failed with exit code ${code}`));
           return;
         }
         resolve(stdout);

package/src/helpers/field-crud-managers/ManyToOneRelationFieldCrudManager.ts

@@ -77,13 +77,13 @@ export class ManyToOneRelationFieldCrudManager implements FieldCrudManager {
         if (isNotEmpty(fieldId)) {
             dto[this.options.fieldName] = await this.options.entityManager.getRepository(coModelEntityName).findOneBy({ id: fieldId });
             if (this.options.required && isEmpty(dto[this.options.fieldName])) {
-                throw new Error(`ManyToOneRelationFieldCrudManager: Record with id: ${fieldId} not found in ${this.options.relationCoModelSingularName}`);
+                throw new Error(`Field ${this.options.fieldName} resolution failed. Record with id: ${fieldId} not found in ${this.options.relationCoModelSingularName}`);
             }
         }
         else {
             dto[this.options.fieldName] = await this.options.entityManager.getRepository(coModelEntityName).findOneBy({ [this.options.relationCoModelUserKeyFieldName]: fieldUserKeyValue });
             if (this.options.required && isEmpty(dto[this.options.fieldName])) {
-                throw new Error(`ManyToOneRelationFieldCrudManager: Record with userKey: ${this.options.relationCoModelUserKeyFieldName}: ${fieldUserKeyValue} not found in ${this.options.relationCoModelSingularName}`);
+                throw new Error(`Field ${this.options.fieldName} resolution failed. Record with userKey: ${this.options.relationCoModelUserKeyFieldName}: ${fieldUserKeyValue} not found in ${this.options.relationCoModelSingularName}`);
             }
         }
 

package/src/helpers/schematic.service.ts

@@ -1,7 +1,7 @@
 import { Injectable, Logger } from '@nestjs/common';
 import { snakeCase } from "lodash";
 import { FieldMetadata } from 'src/entities/field-metadata.entity';
-import { CommandService } from './command.service';
+import { CommandService, CommandWithArgs } from './command.service';
 import { SolidRegistry } from './solid-registry';
 
 export const ADD_MODULE_COMMAND = 'add-module';
@@ -17,7 +17,7 @@ type ModelAndFieldGenerationOptions = {
   table?: string;
   dataSource: string;
   modelEnableSoftDelete?: boolean;
-  parentModel?: string; 
+  parentModel?: string;
   parentModule?: string;
   draftPublishWorkflowEnabled?: boolean;
   isLegacyTable?: boolean;
@@ -33,6 +33,8 @@ export const REFRESH_MODEL_COMMAND = 'refresh-model';
 export class SchematicService {
   private readonly logger = new Logger(SchematicService.name);
   private readonly SCHEMATIC_PROJECT = '@solidstarters/solid-code-builder';
+  private readonly SCHEMATICS_COMMAND = 'schematics';
+
   constructor(private readonly commandService: CommandService, private readonly solidRegistry: SolidRegistry) { }
 
   async executeSchematicCommand(
@@ -40,91 +42,95 @@ export class SchematicService {
     options: GenerateModuleOptions | ModelAndFieldGenerationOptions,
     debug = false,
   ): Promise<string> {
-    return await this.commandService.executeCommand(
-      this.generateSchematicCommand(command, options, debug),
-    );
+    const commandWithArgs = this.generateSchematicCommand(command, options, debug);
+    return await this.commandService.executeCommandWithArgs(commandWithArgs);
   }
 
   private generateSchematicCommand(
     command: string,
     options: GenerateModuleOptions | ModelAndFieldGenerationOptions,
     debug: boolean,
-  ): string {
-    const baseCommand = `schematics ${this.SCHEMATIC_PROJECT}:${command} --debug=${debug}`;
+  ): CommandWithArgs {
+    const schematicName = `${this.SCHEMATIC_PROJECT}:${command}`;
+    const baseArgs = [schematicName, `--debug=${debug}`];
+
     if (
       command === REMOVE_FIELDS_COMMAND ||
       command === REFRESH_MODEL_COMMAND
     ) {
-      const {fields, ...modelSpecificOptions} = options as ModelAndFieldGenerationOptions;
-      const modelCommand = this.buildModelGenerationCommand(baseCommand, modelSpecificOptions);
-      const fieldCommand = this.buildFieldGenerationCommand(fields);
-      const schematicCommand = modelCommand + ' ' + fieldCommand;
-      this.logger.debug('schematicCommand', schematicCommand);
-      return schematicCommand;
+      const { fields, ...modelSpecificOptions } = options as ModelAndFieldGenerationOptions;
+      const modelArgs = this.buildModelGenerationArgs(modelSpecificOptions);
+      const fieldArgs = this.buildFieldGenerationArgs(fields);
+      const args = [...baseArgs, ...modelArgs, ...fieldArgs];
+      this.logger.debug('schematicCommand args', args);
+      return { command: this.SCHEMATICS_COMMAND, args };
     } else if (command === ADD_MODULE_COMMAND) {
       const moduleOptions = options as GenerateModuleOptions;
-      const schematicCommand = ` ${baseCommand} --module=${moduleOptions.module}`;
-      this.logger.debug('schematicCommand', schematicCommand);
-      return schematicCommand;
+      const args = [...baseArgs, `--module=${moduleOptions.module}`];
+      this.logger.debug('schematicCommand args', args);
+      return { command: this.SCHEMATICS_COMMAND, args };
     } else {
       throw new Error('Schematic command not supported.');
     }
   }
 
-  private buildFieldGenerationCommand(fields: FieldMetadata[]) {
+  private buildFieldGenerationArgs(fields: FieldMetadata[]): string[] {
     return fields
       .filter((field) => {
         return !this.solidRegistry.getCommonEntityKeys().map(key => key.toString()).includes(field.name);
       })
       .map((field) => {
-        return `--fields='${JSON.stringify(field).replace(/'/g, "\\'")}'`;
-      })
-      .join(' ');
+        // Using argument array eliminates the need for shell-specific quoting
+        return `--fields=${JSON.stringify(field)}`;
+      });
   }
 
-  private buildModelGenerationCommand(baseCommand: string, modelSpecificOptions: ModelGenerationOptions): string {
-    let modelCommand = `${baseCommand} --module=${modelSpecificOptions.module} --model=${modelSpecificOptions.model}`;
+  private buildModelGenerationArgs(modelSpecificOptions: ModelGenerationOptions): string[] {
+    const args: string[] = [
+      `--module=${modelSpecificOptions.module}`,
+      `--model=${modelSpecificOptions.model}`,
+    ];
 
-    // Make below options code generate i.e if option exists then add to command with proper casing
     if (modelSpecificOptions.moduleDisplayName) {
-      modelCommand += ` --module-display-name=${snakeCase(modelSpecificOptions.moduleDisplayName)}`;
+      args.push(`--module-display-name=${snakeCase(modelSpecificOptions.moduleDisplayName)}`);
     }
 
     if (modelSpecificOptions.table) {
-      modelCommand += ` --table=${modelSpecificOptions.table}`;
+      args.push(`--table=${modelSpecificOptions.table}`);
     }
 
     if (modelSpecificOptions.dataSource) {
-      modelCommand += ` --data-source=${modelSpecificOptions.dataSource}`;
+      args.push(`--data-source=${modelSpecificOptions.dataSource}`);
     }
 
     if (modelSpecificOptions.modelEnableSoftDelete) {
-      modelCommand += ` --model-enable-soft-delete=${modelSpecificOptions.modelEnableSoftDelete}`;
+      args.push(`--model-enable-soft-delete=${modelSpecificOptions.modelEnableSoftDelete}`);
     }
 
     if (modelSpecificOptions.parentModel) {
-      modelCommand += ` --parent-model=${modelSpecificOptions.parentModel}`;
+      args.push(`--parent-model=${modelSpecificOptions.parentModel}`);
     }
+
     if (modelSpecificOptions.parentModule) {
-      modelCommand += ` --parent-module=${modelSpecificOptions.parentModule}`;
+      args.push(`--parent-module=${modelSpecificOptions.parentModule}`);
     }
 
     if (modelSpecificOptions.draftPublishWorkflowEnabled) {
-      modelCommand += ` --draft-publish-workflow-enabled=${modelSpecificOptions.draftPublishWorkflowEnabled}`;
+      args.push(`--draft-publish-workflow-enabled=${modelSpecificOptions.draftPublishWorkflowEnabled}`);
     }
 
     if (modelSpecificOptions.isLegacyTable) {
-      modelCommand += ` --is-legacy-table=${modelSpecificOptions.isLegacyTable}`;
+      args.push(`--is-legacy-table=${modelSpecificOptions.isLegacyTable}`);
     }
 
     if (modelSpecificOptions.isLegacyTableWithId) {
-      modelCommand += ` --is-legacy-table-with-id=${modelSpecificOptions.isLegacyTableWithId}`;
+      args.push(`--is-legacy-table-with-id=${modelSpecificOptions.isLegacyTableWithId}`);
     }
 
     if (modelSpecificOptions.dataSourceType) {
-      modelCommand += ` --data-source-type=${modelSpecificOptions.dataSourceType}`;
+      args.push(`--data-source-type=${modelSpecificOptions.dataSourceType}`);
     }
-    
-    return modelCommand;
+
+    return args;
   }
 }

package/src/repository/scheduled-job.repository.ts

@@ -70,6 +70,7 @@ export class ScheduledJobRepository extends SolidBaseRepository<ScheduledJob> {
       job: populatedScheduledJob.job,
       moduleUserKey: populatedScheduledJob.module.name,
       moduleId: populatedScheduledJob.module.id,
+      cronExpression: populatedScheduledJob.cronExpression,
     };
   }
 

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

@@ -88,7 +88,7 @@ export class ModuleMetadataSeederService {
         // Module specific seeding steps.
         // Get all the module metadata files which needs to be seeded.
         const seedDataFiles = this.seedDataFiles;
-        this.logger.debug(`Seed data files are: ${seedDataFiles}`);
+        this.logger.debug(`Found seed data for modules: ${seedDataFiles.map(s => s.moduleMetadata?.name)}`);
 
         /** -------------------------------------------------------------
          * Selective module seeding via: 

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

@@ -2613,7 +2613,8 @@
               "Hourly:Hourly",
               "Daily:Daily",
               "Weekly:Weekly",
-              "Monthly:Monthly"
+              "Monthly:Monthly",
+              "Custom:Custom"
             ],
             "selectionValueType": "string",
             "required": true,
@@ -2787,6 +2788,19 @@
             "selectionDynamicProvider": "ListOfScheduledJobsSelectionProvider",
             "selectionDynamicProviderCtxt": "{}"
           },
+          {
+            "name": "cronExpression",
+            "displayName": "Cron Expression",
+            "type": "shortText",
+            "ormType": "varchar",
+            "length": 512,
+            "required": false,
+            "unique": false,
+            "index": false,
+            "private": false,
+            "encrypt": false,
+            "isSystem": false
+          },
           {
             "name": "module",
             "displayName": "Module",
@@ -10306,6 +10320,12 @@
                                   "name": "frequency"
                                 }
                               },
+                              {
+                                "type": "field",
+                                "attrs": {
+                                  "name": "cronExpression"
+                                }
+                              },
                               {
                                 "type": "field",
                                 "attrs": {

package/src/seeders/system-fields-seeder.service.ts

@@ -53,5 +53,8 @@ export class SystemFieldsSeederService {
       }));
       await this.fieldMetadataRepository.save(newFields);
     }
+    else {
+      this.logger.debug(`No missing system fields for model: ${model.singularName}`);
+    }
   }
 }

package/src/services/authentication.service.ts

@@ -155,9 +155,9 @@ export class AuthenticationService {
 
     async signUp(signUpDto: SignUpDto, activeUser: ActiveUserData = null): Promise<User> {
         // If public registrations are disabled and no activeUser is present when invoking signUp then we throw an exception.
-        if (!(this.settingService.getConfigValue<SolidCoreSetting>('allowPublicRegistration')) && !activeUser) {
-            throw new BadRequestException(ERROR_MESSAGES.PUBLIC_REGISTRATION_DISABLED);
-        }
+        // if (!(this.settingService.getConfigValue<SolidCoreSetting>('allowPublicRegistration')) && !activeUser) {
+        //     throw new BadRequestException(ERROR_MESSAGES.PUBLIC_REGISTRATION_DISABLED);
+        // }
 
         try {
             const onForcePasswordChange = this.settingService.getConfigValue<SolidCoreSetting>('forceChangePasswordOnFirstLogin');

package/src/services/file.service.ts

@@ -1,13 +1,12 @@
-import { Inject, Injectable, Logger } from '@nestjs/common';
+import { Injectable, Logger } from '@nestjs/common';
 import * as fs from 'fs';
 // import * as AWS from 'aws-sdk';
-import { S3Client, PutObjectCommand, DeleteObjectCommand, ObjectCannedACL, GetObjectCommand } from '@aws-sdk/client-s3';
-import { ConfigType } from '@nestjs/config';
-import path from 'path';
-import { Readable } from 'stream';
+import { DeleteObjectCommand, GetObjectCommand, PutObjectCommand, S3Client } from '@aws-sdk/client-s3';
 import { getSignedUrl as awsGetSignedUrl } from '@aws-sdk/s3-request-presigner';
+import path from 'path';
 import { ERROR_MESSAGES } from 'src/constants/error-messages';
 import { AwsS3Config } from 'src/interfaces';
+import { Readable } from 'stream';
 
 @Injectable()
 export class FileService {

package/src/services/scheduled-jobs/scheduler.service.ts

@@ -6,6 +6,7 @@ import { ScheduledJob } from 'src/entities/scheduled-job.entity';
 import { SolidRegistry } from 'src/helpers/solid-registry';
 import { ScheduledJobRepository } from 'src/repository/scheduled-job.repository';
 import { ISchedulerService } from './scheduler.interface';
+import { CronExpressionParser } from 'cron-parser';
 
 @Injectable()
 export class SchedulerServiceImpl implements ISchedulerService {
@@ -93,6 +94,13 @@ export class SchedulerServiceImpl implements ISchedulerService {
             if (timeNow > jobEnd) return false;
         }
 
+        // 3. Check custom frequency
+        if (job.frequency.toLowerCase() === 'custom') {
+            // Custom cron expressions handle their own scheduling logic
+            // Just check if nextRunAt is due, which was already checked in the query
+            return true;
+        }
+
         // 3. Check dayOfWeek (for weekly)
         if (job.frequency.toLowerCase() === 'weekly' && job.dayOfWeek) {
             const todayName = now.toLocaleString('en-US', { weekday: 'long' }); // e.g., "Monday"
@@ -110,6 +118,36 @@ export class SchedulerServiceImpl implements ISchedulerService {
         return true;
     }
 
+    private computeNextRunForCustomCron(job: ScheduledJob, from: Date): Date {
+        const base = new Date(from);
+
+        if (!job.cronExpression) {
+            this.logger.error(`Custom frequency requires cronExpression for job ${job.scheduleName}`);
+            // Fallback to daily if cron expression is missing
+            return new Date(base.getTime() + 24 * 60 * 60 * 1000);
+        }
+
+        try {
+            const interval = CronExpressionParser.parse(job.cronExpression, {
+                currentDate: from,
+                tz: 'UTC'
+            });
+            const nextRun = interval.next().toDate();
+
+            // Validate minimum 1 minute interval
+            if (nextRun.getTime() - from.getTime() < 60000) {
+                throw new Error('Cron expression interval must be at least 1 minute');
+            }
+            
+            this.logger.log(`Custom cron '${job.cronExpression}' next run: ${nextRun}`);
+            return nextRun;
+        } catch (error) {
+            this.logger.error(`Invalid cron expression for job ${job.scheduleName}: ${job.cronExpression}`, error);
+            // Fallback to daily if cron parsing fails
+            return new Date(base.getTime() + 24 * 60 * 60 * 1000);
+        }
+    }
+
     private computeNextRunAt(job: ScheduledJob, from: Date): Date {
         const base = new Date(from);
 
@@ -128,9 +166,8 @@ export class SchedulerServiceImpl implements ISchedulerService {
                 const next = new Date(base);
                 next.setMonth(base.getMonth() + 1);
                 return next;
-            // case 'custom':
-            //     // Optional: let job handler decide via metadata or registry
-            //     return new Date(base.getTime() + 24 * 60 * 60 * 1000);
+            case 'custom':
+                return this.computeNextRunForCustomCron(job, from);
             default:
                 return new Date(base.getTime() + 24 * 60 * 60 * 1000);
         }

package/# Password field.md

@@ -1,8 +0,0 @@
-# Password field
-## Create Scenario
-- password
-- passwordConfirm (stuck)
-## Update Scenario
-- A button will show up instead & password fields won't be shown in the form
-- Clicking on the button will open a modal containing the password & passwordConfirm fields, with a button named as "Update". clicking on Update will patch the record with the password & passwordConfirm fields
-- Add an extra in validateAndTranform in crud service i.e isUpdate i.e default false. this will true when update method of crud service is called. Add logic in PasswordFieldCrudManager to throw required error only if !isUpdate

package/dist/services/file/file-service.interface.d.ts

@@ -1,22 +0,0 @@
-import { Readable } from 'stream';
-export interface WriteOptions {
-    contentType?: string;
-}
-export interface CopyOptions {
-    contentType?: string;
-    overwrite?: boolean;
-}
-export interface UrlOptions {
-    expiresIn?: number;
-}
-export interface IFileService {
-    read(path: string): Promise<Buffer>;
-    write(path: string, data: Buffer | string, options?: WriteOptions): Promise<void>;
-    writeStream(path: string, stream: Readable, options?: WriteOptions): Promise<void>;
-    delete(path: string): Promise<void>;
-    exists(path: string): Promise<boolean>;
-    copy(sourcePath: string, destinationPath: string, options?: CopyOptions): Promise<void>;
-    getUrl(path: string, options?: UrlOptions): Promise<string>;
-}
-export declare const FILE_SERVICE: unique symbol;
-//# sourceMappingURL=file-service.interface.d.ts.map

package/dist/services/file/file-service.interface.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"file-service.interface.d.ts","sourceRoot":"","sources":["../../../src/services/file/file-service.interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAElC,MAAM,WAAW,YAAY;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,WAAW;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,UAAU;IAEzB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAMD,MAAM,WAAW,YAAY;IAK3B,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAQpC,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAQlF,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAMnF,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAMpC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAQvC,IAAI,CAAC,UAAU,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAQxF,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CAC7D;AAED,eAAO,MAAM,YAAY,eAAyB,CAAC"}

package/dist/services/file/file-service.interface.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FILE_SERVICE = void 0;
-exports.FILE_SERVICE = Symbol('FILE_SERVICE');
-//# sourceMappingURL=file-service.interface.js.map

package/dist/services/file/file-service.interface.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"file-service.interface.js","sourceRoot":"","sources":["../../../src/services/file/file-service.interface.ts"],"names":[],"mappings":";;;AAyEa,QAAA,YAAY,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC","sourcesContent":["import { Readable } from 'stream';\n\nexport interface WriteOptions {\n  contentType?: string;\n}\n\nexport interface CopyOptions {\n  contentType?: string;\n  /** Whether to overwrite existing file (default: true) */\n  overwrite?: boolean;\n}\n\nexport interface UrlOptions {\n  /** Expiry time in seconds (relevant for S3 signed URLs) */\n  expiresIn?: number;\n}\n\n/**\n * Unified interface for file operations.\n * Implementations: DiskFileService, S3FileService\n */\nexport interface IFileService {\n  /**\n   * Read file contents as Buffer\n   * @param path - File path (disk) or key (S3)\n   */\n  read(path: string): Promise<Buffer>;\n\n  /**\n   * Write data to a file\n   * @param path - File path (disk) or key (S3)\n   * @param data - Content to write\n   * @param options - Optional write options (e.g., contentType for S3)\n   */\n  write(path: string, data: Buffer | string, options?: WriteOptions): Promise<void>;\n\n  /**\n   * Write a stream to a file\n   * @param path - File path (disk) or key (S3)\n   * @param stream - Readable stream\n   * @param options - Optional write options (e.g., contentType for S3)\n   */\n  writeStream(path: string, stream: Readable, options?: WriteOptions): Promise<void>;\n\n  /**\n   * Delete a file\n   * @param path - File path (disk) or key (S3)\n   */\n  delete(path: string): Promise<void>;\n\n  /**\n   * Check if file exists\n   * @param path - File path (disk) or key (S3)\n   */\n  exists(path: string): Promise<boolean>;\n\n  /**\n   * Copy a file from source to destination\n   * @param sourcePath - Source file path\n   * @param destinationPath - Destination file path\n   * @param options - Optional copy options\n   */\n  copy(sourcePath: string, destinationPath: string, options?: CopyOptions): Promise<void>;\n\n  /**\n   * Get an accessible URL for the file\n   * For S3: returns signed URL; For disk: returns the file path\n   * @param path - File path (disk) or key (S3)\n   * @param options - URL options (e.g., expiresIn for S3)\n   */\n  getUrl(path: string, options?: UrlOptions): Promise<string>;\n}\n\nexport const FILE_SERVICE = Symbol('FILE_SERVICE');\n"]}