@solidxai/core 0.1.6-beta.0 → 0.1.6-beta.10

package/src/services/scheduled-job.service.ts

@@ -1,10 +1,12 @@
-import { Injectable, Logger } from '@nestjs/common';
+import { BadRequestException, Injectable, Logger, NotFoundException } from '@nestjs/common';
 import { ModuleRef } from "@nestjs/core";
 import { InjectEntityManager } from '@nestjs/typeorm';
 import { ScheduledJob } from 'src/entities/scheduled-job.entity';
+import { SolidRegistry } from 'src/helpers/solid-registry';
 import { ScheduledJobRepository } from 'src/repository/scheduled-job.repository';
 import { EntityManager } from 'typeorm';
 import { CRUDService } from './crud.service';
+import { SchedulerServiceImpl } from './scheduled-jobs/scheduler.service';
 
 @Injectable()
 export class ScheduledJobService extends CRUDService<ScheduledJob> {
@@ -16,9 +18,36 @@ export class ScheduledJobService extends CRUDService<ScheduledJob> {
     // @InjectRepository(ScheduledJob)
     // readonly repo: Repository<ScheduledJob>,
     readonly repo: ScheduledJobRepository,
-    readonly moduleRef: ModuleRef
+    readonly moduleRef: ModuleRef,
+    private readonly solidRegistry: SolidRegistry,
+    private readonly schedulerService: SchedulerServiceImpl,
 
   ) {
     super(entityManager, repo, 'scheduledJob', 'solid-core', moduleRef);
   }
+
+  async triggerRun(id: number): Promise<ScheduledJob> {
+    const job = await this.repo.findOne({ where: { id } });
+    if (!job) {
+      throw new NotFoundException(`Scheduled job with id ${id} not found`);
+    }
+
+    const handler = this.solidRegistry.getScheduledJobProviderInstance(job.job);
+    if (!handler) {
+      throw new BadRequestException(`Scheduled job handler not found: ${job.job}`);
+    }
+
+    this.logger.log(`Manually triggering scheduled job id=${job.id}, job=${job.job}`);
+
+    await handler.execute(job);
+
+    const finishedAt = new Date();
+    job.lastRunAt = finishedAt;
+    job.nextRunAt = this.schedulerService.computeNextRunAt(job, finishedAt);
+    await this.repo.save(job);
+
+    this.logger.log(`Completed manual trigger for scheduled job id=${job.id}, nextRunAt=${job.nextRunAt?.toISOString?.()}`);
+
+    return job;
+  }
 }

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

@@ -1,3 +1,6 @@
+import { ScheduledJob } from "src/entities/scheduled-job.entity";
+
 export interface ISchedulerService {
     runScheduledJobs(): Promise<void>;
-}
+    computeNextRunAt(job: ScheduledJob, from: Date): Date;
+}

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

@@ -24,13 +24,23 @@ export class SchedulerServiceImpl implements ISchedulerService {
     async runScheduledJobs(): Promise<void> {
         const solidSchedulerEnabled = process.env.SOLID_SCHEDULER_ENABLED || "true";
         if (solidSchedulerEnabled.toLowerCase() !== "true") {
-            // this.logger.debug('Solid scheduler is disabled via environment variable');
+            this.logger.debug('Solid scheduler is disabled via environment variable');
             return;
         }
         const solidCliRunning = process.env.SOLID_CLI_RUNNING || "false";
         if (solidCliRunning === "true") {
             return;
         }
+        const jobsRegexToEnable = (process.env.SOLID_SCHEDULER_JOBS_REGEX_TO_ENABLE || '').trim();
+        let jobsRegex: RegExp | null = null;
+        if (jobsRegexToEnable && jobsRegexToEnable !== "all") {
+            try {
+                jobsRegex = new RegExp(jobsRegexToEnable);
+            } catch (error) {
+                this.logger.error(`Invalid SOLID_SCHEDULER_JOBS_REGEX_TO_ENABLE regex "${jobsRegexToEnable}". Scheduler loop will skip this run.`);
+                return;
+            }
+        }
 
         const now = new Date();
 
@@ -53,6 +63,12 @@ export class SchedulerServiceImpl implements ISchedulerService {
 
         for (const job of dueJobs) {
             const jobKey = String(job.id ?? job.scheduleName ?? job.job);
+            const jobName = String(job.job ?? '');
+
+            if (jobsRegex && !jobsRegex.test(jobName)) {
+                this.logger.log(`[${now.getTime()}]: scheduler service skipping job ${jobName} because it does not match SOLID_SCHEDULER_JOBS_REGEX_TO_ENABLE=${jobsRegexToEnable}`);
+                continue;
+            }
 
             if (this.runningJobs.has(jobKey)) {
                 this.logger.log(`[${now.getTime()}]: scheduler service skipping job ${job.job} because a run is already in progress`);
@@ -94,22 +110,21 @@ export class SchedulerServiceImpl implements ISchedulerService {
     }
 
     private shouldRunNow(job: ScheduledJob, now: Date): boolean {
-        const today = now.toISOString().split('T')[0]; // yyyy-mm-dd
-        const timeNow = now.toTimeString().slice(0, 5); // hh:mm
+        const today = new Date(now);
+        today.setHours(0, 0, 0, 0);
+        const timeNow = this.toHHMM(now); // hh:mm
 
         // 1. Check startDate / endDate
-        if (job.startDate && new Date(today) < new Date(job.startDate)) return false;
-        if (job.endDate && new Date(today) > new Date(job.endDate)) return false;
+        const startDate = this.toDateOnly(job.startDate as unknown as Date | string | null);
+        const endDate = this.toDateOnly(job.endDate as unknown as Date | string | null);
+        if (startDate && today < startDate) return false;
+        if (endDate && today > endDate) return false;
 
         // 2. Check startTime / endTime
-        if (job.startTime) {
-            const jobStart = job.startTime.toTimeString().slice(0, 5);
-            if (timeNow < jobStart) return false;
-        }
-        if (job.endTime) {
-            const jobEnd = job.endTime.toTimeString().slice(0, 5);
-            if (timeNow > jobEnd) return false;
-        }
+        const jobStart = this.toHHMM(job.startTime as unknown as Date | string | null);
+        const jobEnd = this.toHHMM(job.endTime as unknown as Date | string | null);
+        if (jobStart && timeNow < jobStart) return false;
+        if (jobEnd && timeNow > jobEnd) return false;
 
         // 3. Check custom frequency
         if (job.frequency.toLowerCase() === 'custom') {
@@ -121,8 +136,7 @@ export class SchedulerServiceImpl implements ISchedulerService {
         // 3. Check dayOfWeek (for weekly)
         if (job.frequency.toLowerCase() === 'weekly' && job.dayOfWeek) {
             const todayName = now.toLocaleString('en-US', { weekday: 'long' }); // e.g., "Monday"
-            // const days = job.dayOfWeek.split(',').map(d => d.trim());
-            const days = JSON.parse(job.dayOfWeek) as string[];
+            const days = this.parseDayOfWeek(job.dayOfWeek);
             if (!days.includes(todayName)) return false;
         }
 
@@ -135,7 +149,53 @@ export class SchedulerServiceImpl implements ISchedulerService {
         return true;
     }
 
-    private computeNextRunForCustomCron(job: ScheduledJob, from: Date): Date {
+    private parseDayOfWeek(dayOfWeek: string): string[] {
+        try {
+            const parsed = JSON.parse(dayOfWeek);
+            return Array.isArray(parsed) ? parsed : [];
+        } catch (error) {
+            this.logger.warn(`Invalid dayOfWeek JSON '${dayOfWeek}'`, error as any);
+            return [];
+        }
+    }
+
+    private toDateOnly(value: Date | string | null | undefined): Date | null {
+        if (!value) return null;
+
+        if (value instanceof Date) {
+            const d = new Date(value);
+            d.setHours(0, 0, 0, 0);
+            return d;
+        }
+
+        const parsed = new Date(value);
+        if (Number.isNaN(parsed.getTime())) return null;
+
+        parsed.setHours(0, 0, 0, 0);
+        return parsed;
+    }
+
+    private toHHMM(value: Date | string | null | undefined): string | null {
+        if (!value) return null;
+
+        if (value instanceof Date) {
+            return value.toTimeString().slice(0, 5);
+        }
+
+        if (typeof value === 'string') {
+            const match = value.match(/^(\d{2}):(\d{2})/);
+            if (match) return `${match[1]}:${match[2]}`;
+
+            const parsed = new Date(value);
+            if (!Number.isNaN(parsed.getTime())) {
+                return parsed.toTimeString().slice(0, 5);
+            }
+        }
+
+        return null;
+    }
+
+    public computeNextRunForCustomCron(job: ScheduledJob, from: Date): Date {
         const base = new Date(from);
 
         if (!job.cronExpression) {
@@ -150,22 +210,24 @@ export class SchedulerServiceImpl implements ISchedulerService {
                 tz: 'UTC'
             });
             const nextRun = interval.next().toDate();
+            const runAfterNext = interval.next().toDate();
 
-            // Validate minimum 1 minute interval
-            if (nextRun.getTime() - from.getTime() < 60000) {
+            // Validate minimum 1 minute cadence between consecutive runs.
+            // Comparing nextRun to "from" is incorrect near minute boundaries.
+            if (runAfterNext.getTime() - nextRun.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);
+            this.logger.error(`Invalid cron expression for job ${job.scheduleName}: ${job.cronExpression}. Reason: ${(error as Error).message}`);
             // Fallback to daily if cron parsing fails
             return new Date(base.getTime() + 24 * 60 * 60 * 1000);
         }
     }
 
-    private computeNextRunAt(job: ScheduledJob, from: Date): Date {
+    public computeNextRunAt(job: ScheduledJob, from: Date): Date {
         const base = new Date(from);
 
         switch (job.frequency.toLowerCase()) {

package/src/services/selection-providers/list-of-dashboard-question-providers-selection-provider.service.ts

@@ -3,6 +3,7 @@ import { SelectionProvider } from "src/decorators/selection-provider.decorator";
 import { SolidRegistry } from "src/helpers/solid-registry";
 import { IDashboardQuestionDataProvider, IDashboardVariableSelectionProvider, ISelectionProvider, ISelectionProviderContext, ISelectionProviderValues } from "../../interfaces";
 import { SQL_DYNAMIC_PROVIDER_NAME } from "../dashboard.service";
+import { CHARTJS_SQL_DATA_PROVIDER_NAME, INBUILT_SQL_DATA_PROVIDERS, PRIME_REACT_DATATABLE_SQL_DATA_PROVIDER_NAME, PRIME_REACT_METER_GROUP_SQL_DATA_PROVIDER_NAME } from "../dashboard-question.service";
 
 
 @SelectionProvider()
@@ -34,7 +35,9 @@ export class ListOfDashboardQuestionProvidersSelectionProvider implements ISelec
     async values(query: string, ctxt: ISelectionProviderContext): Promise<readonly ISelectionProviderValues[]> {
         const dashboardSelectionProviders = this.solidRegistry.getDashboardQuestionDataProviders()
         //Exclude the SQL dynamic provider from the list, (since although it is a dashboard selection provider, it is not a valid option for the user to select)
-        return dashboardSelectionProviders.map(i => {
+        return dashboardSelectionProviders
+        .filter(provider => !INBUILT_SQL_DATA_PROVIDERS.includes(provider.name())) 
+        .map(i => {
             return { label: i.name, value: i.name };
         });
     }

package/src/services/solid-ts-morph.service.ts

@@ -324,6 +324,104 @@ export class SolidTsMorphService {
         return { staged: true, overwritten: false, skipped: false };
     }
 
+
+    //Removes all import declarations from a file whose module specifier matches the given predicate.
+    //Returns the set of identifier names that were imported by the removed declarations.
+    removeImports(
+        filePath: string,
+        filter: (moduleSpecifier: string) => boolean
+    ): { removedIdentifiers: Set<string>; staged: boolean; skipped: boolean } {
+        const abs = this.resolveRepoPath(filePath);
+        if (!existsSync(abs)) {
+            this.logger.warn(`removeImport: file not found at ${filePath}, skipping.`);
+            return { removedIdentifiers: new Set(), staged: false, skipped: true };
+        }
+
+        const existing = this.project.getSourceFile(abs);
+        const sourceFile = existing
+            ? existing
+            : this.project.createSourceFile(abs, readFileSync(abs, "utf8"), { overwrite: true });
+
+        const importsToRemove = sourceFile.getImportDeclarations().filter(decl => {
+            const spec = decl.getModuleSpecifierValue().replace(/\\/g, "/");
+            return filter(spec);
+        });
+
+        if (importsToRemove.length === 0) {
+            return { removedIdentifiers: new Set(), staged: false, skipped: true };
+        }
+
+        const removedIdentifiers = new Set<string>();
+        for (const decl of importsToRemove) {
+            for (const named of decl.getNamedImports()) {
+                removedIdentifiers.add(named.getAliasNode()?.getText() ?? named.getName());
+            }
+            const defaultImport = decl.getDefaultImport();
+            if (defaultImport) removedIdentifiers.add(defaultImport.getText());
+            decl.remove();
+        }
+
+        this.dirtySourceFiles.add(abs);
+        this.logger.log(`Staged removal of ${importsToRemove.length} import(s) in: ${this.rel(abs)}`);
+        return { removedIdentifiers, staged: true, skipped: false };
+    }
+
+    //Removes the given identifier names from all @Module decorator array properties
+    removeModuleMembers(
+        filePath: string,
+        names: Set<string> | string[]
+    ): { staged: boolean; skipped: boolean } {
+        const abs = this.resolveRepoPath(filePath);
+        if (!existsSync(abs)) {
+            this.logger.warn(`removeImportMembers: file not found at ${filePath}, skipping.`);
+            return { staged: false, skipped: true };
+        }
+
+        const identifiers = names instanceof Set ? names : new Set(names);
+        if (identifiers.size === 0) return { staged: false, skipped: true };
+
+        const existing = this.project.getSourceFile(abs);
+        const sourceFile = existing
+            ? existing
+            : this.project.createSourceFile(abs, readFileSync(abs, "utf8"), { overwrite: true });
+
+        const nestModuleClass = sourceFile.getClasses().find(cls =>
+            cls.getDecorators().some(dec => dec.getName() === "Module")
+        );
+        if (!nestModuleClass) {
+            this.logger.warn(`removeImportMembers: no @Module() class found in ${filePath}`);
+            return { staged: false, skipped: true };
+        }
+
+        const moduleDec = nestModuleClass.getDecorators().find(dec => dec.getName() === "Module");
+        const arg0 = moduleDec?.getCallExpression()?.getArguments()[0];
+        if (!arg0 || !Node.isObjectLiteralExpression(arg0)) return { staged: false, skipped: true };
+
+        const meta = arg0 as ObjectLiteralExpression;
+        for (const propName of ["imports", "providers", "controllers", "exports"] as const) {
+            const prop = meta.getProperty(propName);
+            if (!prop || !Node.isPropertyAssignment(prop)) continue;
+            const init = prop.getInitializer();
+            if (!init || !Node.isArrayLiteralExpression(init)) continue;
+            const arr = init as ArrayLiteralExpression;
+            const elements = arr.getElements();
+            for (let i = elements.length - 1; i >= 0; i--) {
+                const elemText = elements[i].getText().trim();
+                // Match direct identifiers (e.g. TestService) or call expressions that reference them (e.g. TypeOrmModule.forFeature([Test])).
+                const shouldRemove = identifiers.has(elemText) ||
+                    [...identifiers].some(id => new RegExp(`\\b${id}\\b`).test(elemText));
+                if (shouldRemove) {
+                    arr.removeElement(i);
+                }
+            }
+        }
+
+        this.dirtySourceFiles.add(abs);
+        this.logger.log(`Staged removal of [${[...identifiers].join(", ")}] from @Module arrays in: ${this.rel(abs)}`);
+        return { staged: true, skipped: false };
+    }
+
+
     addImport(
         filePath: string,
         importLine: string

package/src/solid-core.module.ts

@@ -133,6 +133,8 @@ import { ChatterMessageController } from './controllers/chatter-message.controll
 import { DashboardQuestionSqlDatasetConfigController } from './controllers/dashboard-question-sql-dataset-config.controller';
 import { DashboardQuestionController } from './controllers/dashboard-question.controller';
 import { DashboardVariableController } from './controllers/dashboard-variable.controller';
+import { DashboardLayoutController } from './controllers/dashboard-layout.controller';
+
 import { DashboardController } from './controllers/dashboard.controller';
 import { ExportTemplateController } from './controllers/export-template.controller';
 import { ExportTransactionController } from './controllers/export-transaction.controller';
@@ -156,6 +158,8 @@ import { ChatterMessage } from './entities/chatter-message.entity';
 import { DashboardQuestionSqlDatasetConfig } from './entities/dashboard-question-sql-dataset-config.entity';
 import { DashboardQuestion } from './entities/dashboard-question.entity';
 import { DashboardVariable } from './entities/dashboard-variable.entity';
+import { DashboardLayout } from './entities/dashboard-layout.entity';
+
 import { Dashboard } from './entities/dashboard.entity';
 import { ExportTemplate } from './entities/export-template.entity';
 import { ExportTransaction } from './entities/export-transaction.entity';
@@ -221,6 +225,8 @@ import { DashboardQuestionSqlDatasetConfigRepository } from './repository/dashbo
 import { DashboardQuestionRepository } from './repository/dashboard-question.repository';
 import { DashboardVariableRepository } from './repository/dashboard-variable.repository';
 import { DashboardRepository } from './repository/dashboard.repository';
+import { DashboardLayoutRepository } from './repository/dashboard-layout.repository';
+
 import { EmailTemplateRepository } from './repository/email-template.repository';
 import { ExportTemplateRepository } from './repository/export-template.repository';
 import { ExportTransactionRepository } from './repository/export-transaction.repository';
@@ -263,6 +269,8 @@ import { DashboardVariableSQLDynamicProvider } from './services/dashboard-select
 import { DasbhoardVariableTestDynamicProvider } from './services/dashboard-selection-providers/dashboard-variable-test-dynamic-provider.service';
 import { DashboardVariableService } from './services/dashboard-variable.service';
 import { DashboardService } from './services/dashboard.service';
+import { DashboardLayoutService } from './services/dashboard-layout.service';
+
 import { ExcelService } from './services/excel.service';
 import { ExportTemplateService } from './services/export-template.service';
 import { ExportTransactionService } from './services/export-transaction.service';
@@ -343,6 +351,7 @@ import { ListOfRolesSelectionProvider } from './services/selection-providers/lis
       DashboardQuestion,
       DashboardQuestionSqlDatasetConfig,
       DashboardVariable,
+      DashboardLayout,
       EmailAttachment,
       EmailTemplate,
       ExportTemplate,
@@ -414,6 +423,7 @@ import { ListOfRolesSelectionProvider } from './services/selection-providers/lis
     DashboardQuestionController,
     DashboardQuestionSqlDatasetConfigController,
     DashboardVariableController,
+    DashboardLayoutController,
     EmailTemplateController,
     ExportTemplateController,
     ExportTransactionController,
@@ -638,6 +648,7 @@ import { ListOfRolesSelectionProvider } from './services/selection-providers/lis
     UserActivityHistoryService,
     DashboardService,
     DashboardVariableService,
+    DashboardLayoutService,
     DashboardQuestionService,
     DashboardVariableSQLDynamicProvider,
     DasbhoardVariableTestDynamicProvider,
@@ -682,6 +693,7 @@ import { ListOfRolesSelectionProvider } from './services/selection-providers/lis
     DashboardQuestionSqlDatasetConfigRepository,
     DashboardQuestionRepository,
     DashboardVariableRepository,
+    DashboardLayoutRepository,
     EmailTemplateRepository,
     ExportTemplateRepository,
     ExportTransactionRepository,

package/src/subscribers/computed-entity-field.subscriber.ts

@@ -78,9 +78,9 @@ export class ComputedEntityFieldSubscriber implements EntitySubscriberInterface
             modelName
         );
         //TODO: We can add a feature i.e dependsOn, where we can check if the computed field depends on other computed fields and evaluate them first
-        await Promise.all(
-            computedFieldsTobeEvaluated.map(c => this.evaluateComputedField(this.attachContext(c, eventContext), entity, currentOperation))
-        )
+        for (const computedField of computedFieldsTobeEvaluated) {
+            await this.evaluateComputedField(this.attachContext(computedField, eventContext), entity, currentOperation);
+        }
     }
 
     private handleComputedFieldEvaluationJob(entity: any, currentOperation: ComputedFieldTriggerOperation, modelName: string, eventContext?: TypeOrmEventContext) {
@@ -189,6 +189,12 @@ export class ComputedEntityFieldSubscriber implements EntitySubscriberInterface
         if ("updatedRelations" in event && event.updatedRelations) {
             base.updatedRelations = event.updatedRelations.map((r: any) => r.propertyName);
         }
+        if ("manager" in event && event.manager) {
+            base.manager = event.manager;
+        }
+        if ("queryRunner" in event && event.queryRunner) {
+            base.queryRunner = event.queryRunner;
+        }
         if (event.entity) base.entity = event.entity;
         if ("databaseEntity" in event && event.databaseEntity) {
             base.databaseEntity = event.databaseEntity;

package/src/transformers/typeorm/local-date-time-transformer.ts

@@ -20,59 +20,67 @@ function dateToUtcComponentString(d: Date): string {
     const ss = pad(d.getUTCSeconds());
     const ms = pad(d.getUTCMilliseconds(), 3);
 
-    // A “naive” timestamp string representing the DB wall-clock components
+    // A "naive" timestamp string representing the DB wall-clock components
     return `${yyyy}-${mm}-${dd} ${hh}:${mi}:${ss}.${ms}`;
 }
 
-export const LocalDateTimeTransformer: ValueTransformer & { utc: ValueTransformer } = {
-    // DB → Entity
-    from(value: Date | string | null | undefined): Date | null | undefined {
+function getWallClockConfig(): { tz: string; wallTimeMode: boolean } {
+    return {
+        tz: process.env.SOLIDX_WALL_TIME_TIMEZONE || process.env.SOLIDX_TIMEZONE || "UTC",
+        wallTimeMode: (process.env.SOLIDX_TIME_STORED_AS_WALL_TIME || "").toLowerCase() === "true",
+    };
+}
+
+/**
+ * Returns a dayjs instance positioned at the wall-clock time for the given Date.
+ * - Wall-clock mode ON:  dayjs in the configured timezone (components = wall-clock components)
+ * - Wall-clock mode OFF: dayjs in UTC
+ * Counterpart to serializeDate — use this to format/display a date value correctly.
+ */
+export function parseDate(date: Date): dayjs.Dayjs {
+    const { tz, wallTimeMode } = getWallClockConfig();
+    if (!wallTimeMode) return dayjs.utc(date);
+    return dayjs(date).tz(tz);
+}
 
-        const SOLIDX_WALL_TIME_TZ = process.env.SOLIDX_WALL_TIME_TIMEZONE || process.env.SOLIDX_TIMEZONE || "UTC";
-        const SOLIDX_TIME_STORED_AS_WALL_TIME = (process.env.SOLIDX_TIME_STORED_AS_WALL_TIME || "").toLowerCase() === "true";
+/**
+ * Converts a Date to a string for storage in plain text columns (e.g. audit values).
+ * - Wall-clock mode ON:  "YYYY-MM-DD HH:mm:ss.SSS" in the configured timezone (no Z suffix)
+ * - Wall-clock mode OFF: ISO 8601 UTC string with Z suffix
+ * The presence/absence of the Z suffix lets consumers distinguish the two cases.
+ */
+export function serializeDate(date: Date): string {
+    const { wallTimeMode } = getWallClockConfig();
+    if (!wallTimeMode) return date.toISOString();
+    return parseDate(date).format("YYYY-MM-DD HH:mm:ss.SSS");
+}
 
-        // critical... super important to return undefined here 
+export const LocalDateTimeTransformer: ValueTransformer = {
+    // DB -> Entity
+    from(value: Date | string | null | undefined): Date | null | undefined {
+        // critical... super important to return undefined here
         if (value === undefined) return undefined;
         if (value === null) return null;
 
-        if (!SOLIDX_TIME_STORED_AS_WALL_TIME) {
+        const { tz, wallTimeMode } = getWallClockConfig();
+
+        if (!wallTimeMode) {
             return dayjs(value).toDate();
         }
 
         const naive = value instanceof Date ? dateToUtcComponentString(value) : String(value);
-        return dayjs.tz(naive, SOLIDX_WALL_TIME_TZ).utc().toDate();
+        return dayjs.tz(naive, tz).utc().toDate();
     },
 
-    // Entity → DB
+    // Entity -> DB
     to(value: Date | null | undefined): Date | null | undefined {
-
-        const SOLIDX_WALL_TIME_TZ = process.env.SOLIDX_WALL_TIME_TIMEZONE || process.env.SOLIDX_TIMEZONE || "UTC";
-        const SOLIDX_TIME_STORED_AS_WALL_TIME = (process.env.SOLIDX_TIME_STORED_AS_WALL_TIME || "").toLowerCase() === "true";
-
-        // critical... super important to return undefined here 
+        // critical... super important to return undefined here
         if (value === undefined) return undefined;
         if (value === null) return null;
 
-        if (!SOLIDX_TIME_STORED_AS_WALL_TIME) {
-            return dayjs(value).toDate();
-        }
-
-        const wallTimeStr = dayjs(value).tz(SOLIDX_WALL_TIME_TZ).format("YYYY-MM-DD HH:mm:ss.SSS");
+        const wallTimeStr = serializeDate(value);
         return dayjs.utc(wallTimeStr).toDate();
     },
 
-    utc: {
-        from(value: Date | string | null | undefined): Date | null | undefined {
-            if (value === undefined) return undefined;
-            if (value === null) return null;
-            return dayjs(value).toDate();
-        },
-        to(value: Date | null | undefined): Date | null | undefined {
-            if (value === undefined) return undefined;
-            if (value === null) return null;
-            return dayjs(value).toDate();
-        }
-    }
 };
 
-export const UtcDateTimeTransformer = LocalDateTimeTransformer.utc;

package/.claude/settings.local.json

@@ -1,15 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(node -e:*)",
-      "WebFetch(domain:docs.solidxai.com)",
-      "WebFetch(domain:github.com)",
-      "Read(//Users/oswald/projects/Solid_Starters/solidctl/**)",
-      "Read(//Users/oswald/projects/Solid_Starters/**)",
-      "Bash(find /Users/oswald/projects/Solid_Starters/solid-core-module -type d -name migration* -o -name *database*)"
-    ],
-    "additionalDirectories": [
-      "/Users/oswald/projects/Solid_Starters/solidctl"
-    ]
-  }
-}

package/src/services/1.js

@@ -1,6 +0,0 @@
-1. Do i need to create a storeStreams method for aws service too?
-    - Handle later
-2. queues handling -> if queues is enabled by default, i.e triggerExport(exportTransactionEntity.id).
-    - startExport should either return the data or return the transaction id
-3. How to handle scenarios wherein, nested related exist.(do i need to only get the userkey)
-    - show the userKey