@solidxai/core 0.1.11-beta.1 → 0.1.11-beta.11

package/src/services/crud-helper.service.ts

@@ -5,6 +5,7 @@ import { ActiveUserData } from "src/interfaces/active-user-data.interface";
 import { SolidRegistry } from "src/helpers/solid-registry";
 import { BadRequestException, Logger } from "@nestjs/common";
 import { ERROR_MESSAGES } from "src/constants/error-messages";
+import { buildCastToText } from "src/helpers/typeorm-db-helper";
 
 export enum FilterCombinator {
     AND = '$and',
@@ -101,15 +102,19 @@ export class CrudHelperService {
             case '$eq':
                 qb.andWhere(`${colExpr} = :${uniqueFieldAlias}`, { [uniqueFieldAlias]: normalizedPrimaryOperatorObj.$eq });
                 break;
-            case '$eqi':
-                qb.andWhere(`LOWER(${colExpr}) = :${uniqueFieldAlias}`, { [uniqueFieldAlias]: normalizedPrimaryOperatorObj.$eqi.toLowerCase() });
+            case '$eqi': {
+                const castExpr = buildCastToText(this.getDriver(qb), colExpr);
+                qb.andWhere(`LOWER(${castExpr}) = :${uniqueFieldAlias}`, { [uniqueFieldAlias]: String(normalizedPrimaryOperatorObj.$eqi).toLowerCase() });
                 break;
+            }
             case '$ne':
                 qb.andWhere(`${colExpr} != :${uniqueFieldAlias}`, { [uniqueFieldAlias]: normalizedPrimaryOperatorObj.$ne });
                 break;
-            case '$nei':
-                qb.andWhere(`LOWER(${colExpr}) != :${uniqueFieldAlias}`, { [uniqueFieldAlias]: normalizedPrimaryOperatorObj.$nei.toLowerCase() });
+            case '$nei': {
+                const castExpr = buildCastToText(this.getDriver(qb), colExpr);
+                qb.andWhere(`LOWER(${castExpr}) != :${uniqueFieldAlias}`, { [uniqueFieldAlias]: String(normalizedPrimaryOperatorObj.$nei).toLowerCase() });
                 break;
+            }
             case '$gt':
                 qb.andWhere(`${colExpr} > :${uniqueFieldAlias}`, { [uniqueFieldAlias]: normalizedPrimaryOperatorObj.$gt });
                 break;
@@ -134,12 +139,16 @@ export class CrudHelperService {
             case '$notContains':
                 qb.andWhere(`${colExpr} NOT LIKE :${uniqueFieldAlias}`, { [uniqueFieldAlias]: `%${normalizedPrimaryOperatorObj.$notContains}%` });
                 break;
-            case '$containsi':
-                qb.andWhere(`LOWER(${colExpr}) LIKE :${uniqueFieldAlias}`, { [uniqueFieldAlias]: `%${normalizedPrimaryOperatorObj.$containsi.toLowerCase()}%` });
+            case '$containsi': {
+                const castExpr = buildCastToText(this.getDriver(qb), colExpr);
+                qb.andWhere(`LOWER(${castExpr}) LIKE :${uniqueFieldAlias}`, { [uniqueFieldAlias]: `%${String(normalizedPrimaryOperatorObj.$containsi).toLowerCase()}%` });
                 break;
-            case '$notContainsi':
-                qb.andWhere(`LOWER(${colExpr}) NOT LIKE :${uniqueFieldAlias}`, { [uniqueFieldAlias]: `%${normalizedPrimaryOperatorObj.$notContainsi.toLowerCase()}%` });
+            }
+            case '$notContainsi': {
+                const castExpr = buildCastToText(this.getDriver(qb), colExpr);
+                qb.andWhere(`LOWER(${castExpr}) NOT LIKE :${uniqueFieldAlias}`, { [uniqueFieldAlias]: `%${String(normalizedPrimaryOperatorObj.$notContainsi).toLowerCase()}%` });
                 break;
+            }
             case '$null':
                 qb.andWhere(`${colExpr} IS NULL`);
                 break;
@@ -152,15 +161,19 @@ export class CrudHelperService {
             case '$startsWith':
                 qb.andWhere(`${colExpr} LIKE :${uniqueFieldAlias}`, { [uniqueFieldAlias]: `${normalizedPrimaryOperatorObj.$startsWith}%` });
                 break;
-            case '$startsWithi':
-                qb.andWhere(`LOWER(${colExpr}) LIKE :${uniqueFieldAlias}`, { [uniqueFieldAlias]: `${normalizedPrimaryOperatorObj.$startsWithi.toLowerCase()}%` });
+            case '$startsWithi': {
+                const castExpr = buildCastToText(this.getDriver(qb), colExpr);
+                qb.andWhere(`LOWER(${castExpr}) LIKE :${uniqueFieldAlias}`, { [uniqueFieldAlias]: `${String(normalizedPrimaryOperatorObj.$startsWithi).toLowerCase()}%` });
                 break;
+            }
             case '$endsWith':
                 qb.andWhere(`${colExpr} LIKE :${uniqueFieldAlias}`, { [uniqueFieldAlias]: `%${normalizedPrimaryOperatorObj.$endsWith}` });
                 break;
-            case '$endsWithi':
-                qb.andWhere(`LOWER(${colExpr}) LIKE :${uniqueFieldAlias}`, { [uniqueFieldAlias]: `%${normalizedPrimaryOperatorObj.$endsWithi.toLowerCase()}` });
+            case '$endsWithi': {
+                const castExpr = buildCastToText(this.getDriver(qb), colExpr);
+                qb.andWhere(`LOWER(${castExpr}) LIKE :${uniqueFieldAlias}`, { [uniqueFieldAlias]: `%${String(normalizedPrimaryOperatorObj.$endsWithi).toLowerCase()}` });
                 break;
+            }
             default:
                 throw new Error(`Operator ${operator} is not supported`);
         }

package/src/services/crud.service.ts

@@ -34,6 +34,7 @@ import { SelectionDynamicFieldCrudManager } from "../helpers/field-crud-managers
 import { SelectionStaticFieldCrudManager } from "../helpers/field-crud-managers/SelectionStaticFieldCrudManager";
 import { ShortTextFieldCrudManager } from "../helpers/field-crud-managers/ShortTextFieldCrudManager";
 import { UUIDFieldCrudManager } from "../helpers/field-crud-managers/UUIDFieldCrudManager";
+import { ModelMetadataHelperService } from "src/helpers/model-metadata-helper.service";
 import { FieldCrudManager, MediaWithFullUrl } from "../interfaces";
 import { CrudHelperService, FilterCombinator, UserIdFields } from "./crud-helper.service";
 import { HashingService } from "./hashing.service";
@@ -42,6 +43,7 @@ import { getMediaStorageProvider } from "./mediaStorageProviders";
 import { ModelMetadataService } from "./model-metadata.service";
 import { RequestContextService } from "./request-context.service";
 
+const AUDIT_BEFORE_SNAPSHOT = '__auditBeforeSnapshot';
 
 export class CRUDService<T extends CommonEntity> { // Add two generic value i.e Person,CreatePersonDto, so we get the proper types in our service
 
@@ -185,7 +187,7 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
         }));
     }
 
-    //TODO: Will the updates be partial i.e PATCH or full i.e PUT
+ //TODO: Will the updates be partial i.e PATCH or full i.e PUT
     async update(id: number, updateDto: any, files: Express.Multer.File[] = [], isPartialUpdate: boolean = false, solidRequestContext: any = {}, isUpdate: boolean = false): Promise<T> {
         if (!id) {
             throw new Error(ERROR_MESSAGES.ID_REQUIRED_FOR_UPDATE);
@@ -213,16 +215,8 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
             );
         }
 
-        // // In some instances for legacy tables sometimes id is mapped as a bigint. 
-        // // in these cases the update method ends up attempting to insert records due to some type orm type mismatch issue.
-        // const idFieldMetadata = model.fields.find(f => f.name === 'id');
-        // updateDto.id = idFieldMetadata?.type === 'bigint' ? BigInt(id) : id;
-
-        // This class will be extended by the generated service class i.e PersonService
-        // The data required to identify the model and module name will be passed from the generate CrudService subclass
-        //TODO: Algorithm to create the entity
-        // 1. Fire a query and load all the fields in the provided model name for a particular module
-        // FIXME This can be optimized to take in module name i.e (handle scenario wherein same model exists in multiple modules)
+        // Capture pre-update many-to-many relation state for audit tracking
+        await this.prepareManyToManyAuditSnapshot(entity,id,model.singularName);
         let hasMediaFields = false;
 
         const fieldsToProcess = [...model.fields];
@@ -249,6 +243,37 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
         return savedEntity;
     }
 
+/**
+ * Captures the current state of audit-enabled many-to-many relations
+ * before the entity is updated. The snapshot is attached to the entity
+ * and can be used later for audit comparison.
+ */
+private async prepareManyToManyAuditSnapshot(entity: T,id: number,modelSingularName: string): Promise<void> {
+   const modelMetadataHelperService = this.moduleRef.get(ModelMetadataHelperService, { strict: false });
+        const auditRelationFields = (await modelMetadataHelperService.loadFieldHierarchy(modelSingularName)).filter(field =>
+            field.enableAuditTracking &&
+            field.type === 'relation' &&
+            field.relationType !== 'one-to-many'
+        );
+        if (auditRelationFields.length > 0) {
+            const relations: any = {};
+            auditRelationFields.forEach(field => relations[field.name] = true);
+            const auditBeforeEntity = await this.repo.findOne({
+                where: {
+                    id: id,
+                } as unknown as FindOptionsWhere<T>,
+                relations: relations as any,
+            });
+            if (auditBeforeEntity) {
+                Object.defineProperty(entity, AUDIT_BEFORE_SNAPSHOT, {
+                    configurable: true,
+                    enumerable: false,
+                    value: auditBeforeEntity,
+                    writable: true,
+                });
+            }
+        }
+    }
     //TODO: Will the updates be partial i.e PATCH or full i.e PUT
     async delete(id: number, solidRequestContext: any = {}) {
         if (!id) {

package/src/services/datasource-introspection/mssql-datasource-introspection-provider.service.ts

@@ -39,6 +39,7 @@ export class MssqlDatasourceIntrospectionProviderService implements DatasourceIn
                 c.name AS columnName,
                 ty.name AS dataType,
                 c.is_identity AS isAutoGenerated,
+                CASE WHEN pk.column_id IS NOT NULL THEN 1 ELSE 0 END AS isPrimaryKey,
                 CASE WHEN c.is_nullable = 1 THEN 'YES' ELSE 'NO' END AS isNullable,
                 dc.definition AS defaultValue,
                 CASE
@@ -52,6 +53,16 @@ export class MssqlDatasourceIntrospectionProviderService implements DatasourceIn
             INNER JOIN sys.columns c ON c.object_id = t.object_id
             INNER JOIN sys.types ty ON ty.user_type_id = c.user_type_id
             LEFT JOIN sys.default_constraints dc ON dc.object_id = c.default_object_id
+            LEFT JOIN (
+                SELECT ic.object_id, ic.column_id
+                FROM sys.index_columns ic
+                INNER JOIN sys.key_constraints kc
+                    ON kc.parent_object_id = ic.object_id
+                   AND kc.unique_index_id = ic.index_id
+                WHERE kc.type = 'PK'
+            ) pk
+                ON pk.object_id = c.object_id
+               AND pk.column_id = c.column_id
             WHERE schema_name(t.schema_id) NOT IN ('sys', 'INFORMATION_SCHEMA')
             ORDER BY schema_name(t.schema_id), t.name, c.column_id
         `);
@@ -62,6 +73,7 @@ export class MssqlDatasourceIntrospectionProviderService implements DatasourceIn
             columnName: row.columnName,
             dataType: row.dataType,
             isAutoGenerated: Boolean(row.isAutoGenerated),
+            isPrimaryKey: Boolean(row.isPrimaryKey),
             isNullable: String(row.isNullable).toUpperCase() === "YES",
             defaultValue: row.defaultValue ?? null,
             characterMaximumLength: this.toNumberOrNull(row.characterMaximumLength),

package/src/services/datasource-introspection/mysql-datasource-introspection-provider.service.ts

@@ -39,6 +39,7 @@ export class MysqlDatasourceIntrospectionProviderService implements DatasourceIn
                 COLUMN_NAME AS columnName,
                 DATA_TYPE AS dataType,
                 EXTRA AS extra,
+                COLUMN_KEY AS columnKey,
                 IS_NULLABLE AS isNullable,
                 COLUMN_DEFAULT AS defaultValue,
                 CHARACTER_MAXIMUM_LENGTH AS characterMaximumLength,
@@ -56,6 +57,7 @@ export class MysqlDatasourceIntrospectionProviderService implements DatasourceIn
             columnName: row.columnName,
             dataType: row.dataType,
             isAutoGenerated: String(row.extra ?? "").toLowerCase().includes("auto_increment"),
+            isPrimaryKey: String(row.columnKey ?? "").toUpperCase() === "PRI",
             isNullable: String(row.isNullable).toUpperCase() === "YES",
             defaultValue: row.defaultValue ?? null,
             characterMaximumLength: this.toNumberOrNull(row.characterMaximumLength),

package/src/services/datasource-introspection/postgres-datasource-introspection-provider.service.ts

@@ -34,24 +34,36 @@ export class PostgresDatasourceIntrospectionProviderService implements Datasourc
     async listColumns(dataSource: DataSource): Promise<DatasourceIntrospectionColumn[]> {
         const rows = await dataSource.query(`
             SELECT
-                TABLE_SCHEMA AS "tableSchema",
-                TABLE_NAME AS "tableName",
-                COLUMN_NAME AS "columnName",
-                DATA_TYPE AS "dataType",
+                c.TABLE_SCHEMA AS "tableSchema",
+                c.TABLE_NAME AS "tableName",
+                c.COLUMN_NAME AS "columnName",
+                c.DATA_TYPE AS "dataType",
                 CASE
-                    WHEN is_identity = 'YES' THEN true
-                    WHEN COLUMN_DEFAULT LIKE 'nextval(%' THEN true
+                    WHEN c.is_identity = 'YES' THEN true
+                    WHEN c.COLUMN_DEFAULT LIKE 'nextval(%' THEN true
                     ELSE false
                 END AS "isAutoGenerated",
-                IS_NULLABLE AS "isNullable",
-                COLUMN_DEFAULT AS "defaultValue",
-                CHARACTER_MAXIMUM_LENGTH AS "characterMaximumLength",
-                NUMERIC_PRECISION AS "numericPrecision",
-                NUMERIC_SCALE AS "numericScale",
-                ORDINAL_POSITION AS "ordinalPosition"
-            FROM INFORMATION_SCHEMA.COLUMNS
-            WHERE TABLE_SCHEMA NOT IN ('pg_catalog', 'information_schema')
-            ORDER BY TABLE_SCHEMA, TABLE_NAME, ORDINAL_POSITION
+                EXISTS (
+                    SELECT 1
+                    FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc
+                    INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE kcu
+                        ON kcu.CONSTRAINT_NAME = tc.CONSTRAINT_NAME
+                       AND kcu.TABLE_SCHEMA = tc.TABLE_SCHEMA
+                       AND kcu.TABLE_NAME = tc.TABLE_NAME
+                    WHERE tc.CONSTRAINT_TYPE = 'PRIMARY KEY'
+                      AND tc.TABLE_SCHEMA = c.TABLE_SCHEMA
+                      AND tc.TABLE_NAME = c.TABLE_NAME
+                      AND kcu.COLUMN_NAME = c.COLUMN_NAME
+                ) AS "isPrimaryKey",
+                c.IS_NULLABLE AS "isNullable",
+                c.COLUMN_DEFAULT AS "defaultValue",
+                c.CHARACTER_MAXIMUM_LENGTH AS "characterMaximumLength",
+                c.NUMERIC_PRECISION AS "numericPrecision",
+                c.NUMERIC_SCALE AS "numericScale",
+                c.ORDINAL_POSITION AS "ordinalPosition"
+            FROM INFORMATION_SCHEMA.COLUMNS c
+            WHERE c.TABLE_SCHEMA NOT IN ('pg_catalog', 'information_schema')
+            ORDER BY c.TABLE_SCHEMA, c.TABLE_NAME, c.ORDINAL_POSITION
         `);
 
         return rows.map((row: any) => ({
@@ -60,6 +72,7 @@ export class PostgresDatasourceIntrospectionProviderService implements Datasourc
             columnName: row.columnName,
             dataType: row.dataType,
             isAutoGenerated: Boolean(row.isAutoGenerated),
+            isPrimaryKey: Boolean(row.isPrimaryKey),
             isNullable: String(row.isNullable).toUpperCase() === "YES",
             defaultValue: row.defaultValue ?? null,
             characterMaximumLength: this.toNumberOrNull(row.characterMaximumLength),