@flusys/nestjs-entity-builder 9.2.0 → 9.2.1

package/flow-engine/flow-run.types.d.ts

@@ -60,6 +60,9 @@ export interface IFlowRunState {
     savedUpTo?: IFlowSavePoint;
     callStack: string[];
     pendingEvents: IPendingEvent[];
+    publisher?: {
+        chain: Promise<void>;
+    };
     trace: IFlowTraceEntry[];
     response?: {
         status: number;
@@ -79,6 +82,7 @@ export interface IFlowEnv {
     companyMembers?(companyId: string, branchIds?: string[]): Promise<string[]>;
     assertPermissions(logic: ILogicNode, user: ILoggedUserInfo | null): Promise<void>;
     allowPrivateHttp: boolean;
+    codeModules: Record<string, string>;
     notifications?: INotificationAdapter;
     email?: IEmailAdapter;
 }
@@ -89,6 +93,16 @@ export interface IFlowEntityAccess {
     }, user: ILoggedUserInfo | null, options?: IFlowWriteOptions): Promise<IGenericRecord>;
     delete(id: string, user: ILoggedUserInfo | null, options?: IFlowWriteOptions): Promise<'deleted' | 'purged'>;
     findById(id: string, options?: IFlowReadOptions): Promise<IGenericRecord>;
+    batchInsertable?: boolean;
+    prepareInsert?(dto: Record<string, unknown>): Record<string, unknown>;
+    firstMissingRelation?(rows: Record<string, unknown>[], queryRunner: QueryRunner): Promise<{
+        index: number;
+        error: Error;
+    } | null>;
+    updateLoaded?(row: IGenericRecord, dto: Record<string, unknown>, user: ILoggedUserInfo | null, options?: IFlowWriteOptions): Promise<IGenericRecord>;
+    insertValidated?(rows: Record<string, unknown>[], user: ILoggedUserInfo | null, options: IFlowWriteOptions & {
+        queryRunner: QueryRunner;
+    }): Promise<IGenericRecord[]>;
     getAll(search: string | undefined, dto: {
         filter?: Record<string, unknown>;
         sort?: Record<string, 'ASC' | 'DESC'>;
@@ -107,6 +121,7 @@ export interface IFlowReadOptions {
 }
 export interface IFlowWriteOptions extends IFlowReadOptions {
     publishEvents?: boolean;
+    statementTimeoutMs?: number;
 }
 export interface INodeResult {
     output?: unknown;

package/flow-engine/flow.types.d.ts

@@ -288,6 +288,7 @@ export declare const FLOW_LIMITS: {
     readonly MAX_EMAIL_TEMPLATE_SLUG_LENGTH: 255;
     readonly MAX_HTTP_TIMEOUT_MS: 15000;
     readonly MAX_HTTP_RESPONSE_BYTES: 1000000;
+    readonly DEFAULT_QUERY_LIMIT: 50;
     readonly MAX_QUERY_LIMIT: 200;
     readonly MAX_WRITE_ITEMS: 1000;
     readonly DEFAULT_WRITE_FILTER_LIMIT: 100;
@@ -307,7 +308,6 @@ export declare const FLOW_LIMITS: {
     readonly MIN_CODE_TIMEOUT_MS: 10;
     readonly MAX_CODE_TIMEOUT_MS: 5000;
     readonly CODE_MEMORY_LIMIT_BYTES: number;
-    readonly CODE_STACK_SIZE_BYTES: number;
     readonly MAX_CODE_OUTPUT_BYTES: 1000000;
     readonly MAX_CODE_LOG_LINES: 50;
     readonly MAX_CODE_LOG_LINE_CHARS: 500;

package/guards/designer-writable.interceptor.d.ts

@@ -3,6 +3,7 @@ import { Reflector } from '@nestjs/core';
 import { type Observable } from 'rxjs';
 import { EntityBuilderConfigService } from '../services/entity-builder-config.service.js';
 export declare const DesignerWrites: (...handlers: string[]) => import("@nestjs/common").CustomDecorator<string>;
+export declare const DesignerAllowsRepair: () => import("@nestjs/common").CustomDecorator<string>;
 export declare class DesignerWritableInterceptor implements NestInterceptor {
     private readonly reflector;
     private readonly config;

package/interfaces/definition-bundle.interface.d.ts

@@ -87,6 +87,8 @@ export interface IBundleImportPlan {
 export interface IBundleSettings {
     readOnly: boolean;
     variables: string[];
+    maxFiles: number;
+    maxBytes: number;
 }
 export interface IGeneratedApiKey {
     flowSlug: string;

package/interfaces/entity-builder-module.interface.d.ts

@@ -5,6 +5,9 @@ export interface IEntityBuilderConfig extends IDataSourceServiceOptions {
     events?: IModuleEventsConfig;
     flows?: {
         allowPrivateHttp?: boolean;
+        code?: {
+            modules?: Record<string, string>;
+        };
     };
     bundles?: {
         variables?: Record<string, string>;
@@ -12,9 +15,14 @@ export interface IEntityBuilderConfig extends IDataSourceServiceOptions {
     designer?: {
         readOnly?: boolean;
     };
+    performance?: {
+        fastUpdates?: boolean;
+        partialIndexes?: boolean;
+    };
 }
 export interface EntityBuilderModuleOptions extends IDynamicModuleConfig {
     bootstrapAppConfig?: IBootstrapAppConfig;
+    tenantScopedServices?: boolean;
     config?: IEntityBuilderConfig;
     providers?: Provider[];
 }
@@ -23,6 +31,7 @@ export interface EntityBuilderOptionsFactory {
 }
 export interface EntityBuilderModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
     global?: boolean;
+    tenantScopedServices?: boolean;
     includeController?: boolean;
     bootstrapAppConfig?: IBootstrapAppConfig;
     useFactory?: (...args: any[]) => Promise<IEntityBuilderConfig> | IEntityBuilderConfig;

package/modules/entity-builder.module.d.ts

@@ -5,6 +5,7 @@ export declare class EntityBuilderModule {
     private static readonly EXPORTS;
     static forRoot(options: EntityBuilderModuleOptions): DynamicModule;
     static forRootAsync(options: EntityBuilderModuleAsyncOptions): DynamicModule;
+    private static tenantScoped;
     private static buildProviders;
     private static buildAsyncProviders;
 }

package/modules/index.d.ts

@@ -1 +1,2 @@
 export * from './entity-builder.module.js';
+export * from './tenant-context-id.strategy.js';

package/modules/tenant-context-id.strategy.d.ts

@@ -0,0 +1,16 @@
+import { type ContextId, type ContextIdResolver, type ContextIdStrategy } from '@nestjs/core';
+export interface ITenantContextIdStrategyOptions {
+    tenants?: Iterable<string> | ((tenantId: string) => boolean);
+    maxTenants?: number;
+}
+type TenantRequest = {
+    headers?: Record<string, unknown>;
+};
+export declare class TenantContextIdStrategy implements ContextIdStrategy<TenantRequest> {
+    private readonly tenantContexts;
+    private readonly isTenant;
+    private readonly maxTenants;
+    constructor(options?: ITenantContextIdStrategyOptions);
+    attach(contextId: ContextId, request: TenantRequest): ContextIdResolver | undefined;
+}
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flusys/nestjs-entity-builder",
-  "version": "9.2.0",
+  "version": "9.2.1",
   "description": "Dynamic entity builder module - runtime entity/field metadata, driven DDL, and generic CRUD",
   "type": "module",
   "main": "./fesm/index.js",
@@ -85,8 +85,7 @@
     "rxjs": "^7.8.0"
   },
   "dependencies": {
-    "@flusys/nestjs-core": "9.2.0",
-    "@flusys/nestjs-shared": "9.2.0",
-    "quickjs-emscripten": "^0.32.0"
+    "@flusys/nestjs-core": "9.2.1",
+    "@flusys/nestjs-shared": "9.2.1"
   }
 }

package/services/definition-bundle.diff.d.ts

@@ -54,8 +54,6 @@ export interface IEntityDiff {
     extras: IBundleExtra[];
     blockers: IMessageRef[];
 }
-export declare const FIELD_COMPARED_KEYS: readonly ["label", "fieldType", "nullable", "unique", "isIndexed", "defaultValue", "validationRules", "selectOptions", "relationTarget", "order", "uiConfig", "isSearchable"];
-export declare const ENTITY_COMPARED_KEYS: readonly ["label", "description", "uiConfig", "isSoftDeleteEnabled", "isAuditEnabled", "status"];
 export declare function matchDefinitions<B extends {
     id: string;
     code: string;

package/services/definition-bundle.file.d.ts

@@ -4,4 +4,5 @@ export interface IUploadedBundleFile {
     size: number;
     originalname?: string;
 }
-export declare function readBundleFile(file: IUploadedBundleFile | undefined): IDefinitionBundle;
+export declare function readBundleFile(file: IUploadedBundleFile | undefined, source?: string): IDefinitionBundle;
+export declare function readBundleFiles(files: IUploadedBundleFile[] | undefined): IDefinitionBundle;

package/services/definition-bundle.service.d.ts

@@ -16,7 +16,6 @@ export declare class DefinitionBundleService {
     private readonly dialect;
     private readonly actionRegistry?;
     constructor(provider: EntityBuilderDataSourceProvider, config: EntityBuilderConfigService, schemaSync: SchemaSyncService, evolution: SchemaEvolutionService, flows: FlowDefinitionService, dialect: SchemaDialectAdapterService, actionRegistry?: IPermissionActionRegistry | undefined);
-    private variables;
     export(dto: ExportBundleDto): Promise<IBundleExport>;
     private leftBehind;
     private loadEntities;

package/services/entity-builder-config.service.d.ts

@@ -9,6 +9,9 @@ export declare class EntityBuilderConfigService implements IModuleConfigService
     isMultiTenant(): boolean;
     getOptions(): EntityBuilderModuleOptions;
     getConfig(): import("../index.js").IEntityBuilderConfig | undefined;
+    isFastUpdatesEnabled(): boolean;
+    isPartialIndexesEnabled(): boolean;
     isDesignerReadOnly(): boolean;
+    getCodeModules(): Record<string, string>;
     getBundleVariables(): Record<string, string>;
 }

package/services/entity-builder-datasource.provider.d.ts

@@ -19,6 +19,7 @@ export declare class EntityBuilderDataSourceProvider extends MultiTenantDataSour
     protected createDataSourceFromConfig(config: IDatabaseConfig): Promise<DataSource>;
     getDriver(): Promise<SupportedDbDriver>;
     registerDynamicSchema(schema: EntitySchema): Promise<void>;
+    registerDynamicSchemas(schemas: EntitySchema[]): Promise<void>;
     getDynamicRepository<T extends ObjectLiteral>(schema: EntitySchema<T>): Promise<Repository<T>>;
     getQueryRunner(): Promise<QueryRunner>;
 }

package/services/field-value-validator.d.ts

@@ -11,6 +11,13 @@ export interface IValidatableField {
     selectOptions: unknown[] | null;
     validationRules: Record<string, unknown> | null;
 }
+export declare const valueRulesOf: (field: {
+    code: string;
+    label?: string | null;
+    fieldType: FieldType;
+    selectOptions?: unknown[] | null;
+    validationRules?: Record<string, unknown> | null;
+}) => IValidatableField;
 export declare function validateRecord(fields: IValidatableField[], values: Record<string, unknown>, mode: 'insert' | 'update'): {
     values: Record<string, unknown>;
     errors: IFieldError[];

package/services/flow-definition.service.d.ts

@@ -10,6 +10,7 @@ import { FlowDefinition } from '../entities/flow-definition.entity.js';
 import { type IFlowValidationResult } from '../flow-engine/flow-graph.validator.js';
 import { type IFlowEndpoint, type IFlowSettings } from '../flow-engine/flow.types.js';
 import { type IFlowDefinition, type IFlowSnapshot, type IFlowVersion } from '../interfaces/flow-definition.interface.js';
+import { EntityBuilderConfigService } from './entity-builder-config.service.js';
 import { EntityBuilderDataSourceProvider } from './entity-builder-datasource.provider.js';
 export declare const defaultFlowPermissionCode: (slug: string) => string;
 export declare const flowPermissions: (endpoint: Pick<IFlowEndpoint, "permissions">, slug: string) => ILogicNode;
@@ -31,9 +32,11 @@ export declare class FlowDefinitionService extends ApiService<CreateFlowDefiniti
     private readonly notifications?;
     private readonly email?;
     private readonly companyAccess?;
-    constructor(cacheManager: HybridCache, utilsService: UtilsService, provider: EntityBuilderDataSourceProvider, permissionCache: SharedPermissionCacheService, actionRegistry?: IPermissionActionRegistry | undefined, notifications?: INotificationAdapter | undefined, email?: IEmailAdapter | undefined, companyAccess?: ICompanyAccessResolver | undefined);
+    private readonly config?;
+    constructor(cacheManager: HybridCache, utilsService: UtilsService, provider: EntityBuilderDataSourceProvider, permissionCache: SharedPermissionCacheService, actionRegistry?: IPermissionActionRegistry | undefined, notifications?: INotificationAdapter | undefined, email?: IEmailAdapter | undefined, companyAccess?: ICompanyAccessResolver | undefined, config?: EntityBuilderConfigService | undefined);
     findOrFail(id: string): Promise<FlowDefinition>;
     validate(settings: IFlowSettings): Promise<IFlowValidationResult>;
+    codePackages(): string[];
     private callersOf;
     private assertNotCalled;
     private assertCallersKept;
@@ -57,7 +60,12 @@ export declare class FlowDefinitionService extends ApiService<CreateFlowDefiniti
     restoreVersion(flowId: string, version: number, user: ILoggedUserInfo | null): Promise<FlowDefinition>;
     discardDraft(flowId: string, user: ILoggedUserInfo | null): Promise<FlowDefinition>;
     private saveDraft;
-    protected beforeDeleteOperation(dto: DeleteDto, user: ILoggedUserInfo | null, _qr: QueryRunner): Promise<void>;
+    delete(option: DeleteDto, user: ILoggedUserInfo | null): Promise<null>;
+    protected beforeDeleteOperation(dto: DeleteDto, _user: ILoggedUserInfo | null, _qr: QueryRunner): Promise<void>;
+    protected afterDeleteOperation(deleted: Array<{
+        id: string;
+    }>, _dto: DeleteDto, _user: ILoggedUserInfo | null, qr: QueryRunner): Promise<void>;
+    private deprovisionPermissions;
     private provisionPermissions;
 }
 export {};

package/services/flow-executor.service.d.ts

@@ -27,6 +27,7 @@ export declare class FlowExecutorService {
     private readonly email?;
     private readonly branchHierarchy?;
     private readonly logger;
+    private readonly inFlight;
     constructor(provider: EntityBuilderDataSourceProvider, ruleEngine: RuleEngineService, moduleRef: ModuleRef, permissionCache: SharedPermissionCacheService, config: EntityBuilderConfigService, companyAccess?: ICompanyAccessResolver | undefined, notifications?: INotificationAdapter | undefined, email?: IEmailAdapter | undefined, branchHierarchy?: IBranchHierarchyResolver | undefined);
     run(flow: IFlowSettings, options: IFlowRunOptions): Promise<IFlowRunResult>;
     private execute;
@@ -37,5 +38,7 @@ export declare class FlowExecutorService {
     private findCallable;
     private assertMayCall;
     private createEnv;
+    private publishAfterCommit;
+    whenPublished(): Promise<void>;
     private publishPendingEvents;
 }

package/services/flow-runtime.service.d.ts

@@ -1,4 +1,6 @@
+import { HybridCache } from '@flusys/nestjs-shared/classes';
 import { type ILoggedUserInfo, type IMessageRef } from '@flusys/nestjs-shared/interfaces';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
 import { type TestFlowDto } from '../dtos/flow.dto.js';
 import { FlowDefinition } from '../entities/flow-definition.entity.js';
 import { type IFlowRunResult } from '../flow-engine/flow-run.types.js';
@@ -19,8 +21,11 @@ export declare class FlowRuntimeService {
     private readonly executor;
     private readonly executions;
     private readonly definitions;
-    constructor(provider: EntityBuilderDataSourceProvider, executor: FlowExecutorService, executions: FlowExecutionService, definitions: FlowDefinitionService);
+    private readonly cache?;
+    private readonly utils?;
+    constructor(provider: EntityBuilderDataSourceProvider, executor: FlowExecutorService, executions: FlowExecutionService, definitions: FlowDefinitionService, cache?: HybridCache | undefined, utils?: UtilsService | undefined);
     findActive(slug: string): Promise<FlowDefinition | null>;
+    private activeFlowKey;
     tenantScope(): string;
     handle(flow: FlowDefinition, endpoint: IFlowEndpoint, body: unknown, caller: IFlowCaller, user: ILoggedUserInfo | null): Promise<IFlowRunResult>;
     testRun(dto: TestFlowDto, user: ILoggedUserInfo | null, caller: IFlowCaller): Promise<{

package/services/generic-entity-service.factory.d.ts

@@ -1,12 +1,16 @@
 import { type QueryRunner } from 'typeorm';
+import { EntityBuilderConfigService } from './entity-builder-config.service.js';
 import { EntityBuilderDataSourceProvider } from './entity-builder-datasource.provider.js';
 import { GenericEntityService } from './generic-entity.service.js';
 import { SchemaRegistryService } from './schema-registry.service.js';
 export declare class GenericEntityServiceFactory {
     private readonly schemaRegistry;
     private readonly dataSourceProvider;
-    constructor(schemaRegistry: SchemaRegistryService, dataSourceProvider: EntityBuilderDataSourceProvider);
+    private readonly config?;
+    private readonly relatedById;
+    constructor(schemaRegistry: SchemaRegistryService, dataSourceProvider: EntityBuilderDataSourceProvider, config?: EntityBuilderConfigService | undefined);
     forEntityCode(entityCode: string, queryRunner?: QueryRunner): Promise<GenericEntityService>;
     forEntityDefinitionId(entityDefinitionId: string, queryRunner?: QueryRunner): Promise<GenericEntityService>;
+    private related;
     private build;
 }

package/services/generic-entity.service.d.ts

@@ -1,4 +1,5 @@
 import { type ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
+import { BadRequestException } from '@nestjs/common';
 import { type EntitySchema, type QueryRunner } from 'typeorm';
 import { EntityDefinition } from '../entities/entity-definition.entity.js';
 import { FieldDefinition } from '../entities/field-definition.entity.js';
@@ -19,9 +20,14 @@ export interface IGenericQuery {
 export interface IGenericWriteOptions {
     queryRunner?: QueryRunner;
     publishEvents?: boolean;
+    statementTimeoutMs?: number;
 }
+export declare const statementTimeoutSql: (timeoutMs: number) => string;
 export declare const ACTOR_BRANCH_METADATA_KEY = "_actorBranchId";
 export declare function actorMetadata(user: ILoggedUserInfo | null): Record<string, unknown>;
+export interface IGenericEntityOptions {
+    fastUpdates?: boolean;
+}
 export type RelatedServiceResolver = (entityDefinitionId: string, queryRunner?: QueryRunner) => Promise<GenericEntityService>;
 export declare class GenericEntityService {
     private readonly definition;
@@ -29,35 +35,51 @@ export declare class GenericEntityService {
     private readonly fields;
     private readonly dataSourceProvider;
     private readonly resolveRelated?;
+    private readonly options;
     private repository?;
     private readonly activeFieldCodes;
     private readonly presentSystemColumns;
-    constructor(definition: EntityDefinition, schema: EntitySchema, fields: FieldDefinition[], dataSourceProvider: EntityBuilderDataSourceProvider, resolveRelated?: RelatedServiceResolver | undefined);
+    constructor(definition: EntityDefinition, schema: EntitySchema, fields: FieldDefinition[], dataSourceProvider: EntityBuilderDataSourceProvider, resolveRelated?: RelatedServiceResolver | undefined, options?: IGenericEntityOptions);
     get entityCode(): string;
     private validateValues;
     private throwIfInvalid;
+    private invalid;
     private assertRelationsExist;
+    private relatedNotFound;
+    private existingRelatedIds;
     private notFound;
     private auditFields;
-    private stampDeletedBy;
     private ensureActive;
     private repositoryFor;
     private ensureRepository;
     private validateKeys;
     insert(dto: Record<string, unknown>, user: ILoggedUserInfo | null, options?: IGenericWriteOptions): Promise<IGenericRecord>;
+    prepareInsert(dto: Record<string, unknown>): Record<string, unknown>;
+    firstMissingRelation(rows: Record<string, unknown>[], queryRunner: QueryRunner): Promise<{
+        index: number;
+        error: BadRequestException;
+    } | null>;
+    insertValidated(rows: Record<string, unknown>[], user: ILoggedUserInfo | null, options: IGenericWriteOptions & {
+        queryRunner: QueryRunner;
+    }): Promise<IGenericRecord[]>;
+    get batchInsertable(): boolean;
+    private missingRelations;
     update(dto: Record<string, unknown> & {
         id: string;
     }, user: ILoggedUserInfo | null, options?: IGenericWriteOptions): Promise<IGenericRecord>;
     private insertRow;
+    updateLoaded(row: IGenericRecord, dto: Record<string, unknown>, user: ILoggedUserInfo | null, options?: IGenericWriteOptions): Promise<IGenericRecord>;
     private updateRow;
     private assertUpdatable;
     delete(id: string, user: ILoggedUserInfo | null, options?: IGenericWriteOptions): Promise<'deleted' | 'purged'>;
     findById(id: string, options?: IGenericReadOptions): Promise<IGenericRecord>;
     exists(id: string, options?: IGenericReadOptions): Promise<boolean>;
+    existingIds(ids: string[], options?: IGenericReadOptions): Promise<Set<string>>;
     getAll(search: string | undefined, query: IGenericQuery, options?: IGenericReadOptions): Promise<{
         data: IGenericRecord[];
         total: number;
     }>;
+    private totalOf;
     private applyFilter;
     private conditionSql;
     private listOperand;

package/services/identifier-rules.d.ts

@@ -1,5 +1,4 @@
 import { type FieldType } from '../enums/field-type.enum.js';
-export declare const RESERVED_WORDS: Set<string>;
 export declare function assertValidIdentifier(code: string, kind: 'entity' | 'field'): void;
 export declare function assertIndexableField(field: {
     code: string;

package/services/save-loaded.d.ts

@@ -0,0 +1,2 @@
+import { type EntityTarget, type ObjectLiteral, type QueryRunner } from 'typeorm';
+export declare function saveLoaded<T extends ObjectLiteral>(queryRunner: QueryRunner, target: EntityTarget<T>, entity: T, databaseEntity: T): Promise<T>;

package/services/schema-columns.d.ts

@@ -4,7 +4,10 @@ import { FieldType } from '../enums/field-type.enum.js';
 import { type SupportedDbDriver } from '../interfaces/schema-dialect-adapter.interface.js';
 import { type SchemaDialectAdapterService } from './schema-dialect-adapter.service.js';
 export declare const SYSTEM_COLUMN_NAMES: readonly ["id", "created_at", "updated_at", "deleted_at", "created_by_id", "updated_by_id", "deleted_by_id"];
-export declare const NON_INDEXABLE_FIELD_TYPES: readonly FieldType[];
+export declare const indexedByDefault: (spec: {
+    fieldType: FieldType;
+    isIndexed?: boolean | null;
+}) => boolean;
 export declare const isIndexableFieldType: (fieldType: FieldType) => boolean;
 export interface ISystemColumnFlags {
     isSoftDeleteEnabled: boolean;
@@ -15,7 +18,9 @@ export declare const softDeleteColumn: () => TableColumn;
 export declare const auditColumns: (driver: SupportedDbDriver) => TableColumn[];
 export declare const sameColumns: (columnNames: string[], expected: string[]) => boolean;
 export declare function indexName(prefix: 'idx' | 'uq', table: string, column: string, maxLength: number): string;
-export declare const plainIndex: (table: string, column: string, driver: SupportedDbDriver, adapter: SchemaDialectAdapterService) => TableIndex;
+export declare const LIVE_ROWS_WHERE = "\"deleted_at\" IS NULL";
+export declare const plainIndex: (table: string, column: string, driver: SupportedDbDriver, adapter: SchemaDialectAdapterService, liveOnly?: boolean) => TableIndex;
+export declare const isLiveRowsIndex: (index: Pick<TableIndex, "where">) => boolean;
 export declare const tableUnique: (table: string, column: string, driver: SupportedDbDriver, adapter: SchemaDialectAdapterService) => TableUnique;
 export declare function addUnique(qr: QueryRunner, table: Table, column: string, driver: SupportedDbDriver, adapter: SchemaDialectAdapterService): Promise<void>;
 export declare function buildFieldColumn(field: Pick<FieldDefinition, 'code' | 'fieldType' | 'dbType' | 'nullable' | 'unique'>, driver: SupportedDbDriver, adapter: SchemaDialectAdapterService, options: {

package/services/schema-evolution.service.d.ts

@@ -6,6 +6,7 @@ import { EntityPermissionService } from './entity-permission.service.js';
 import { ReferenceScannerService } from './reference-scanner.service.js';
 import { SchemaChangeExecutor } from './schema-change-executor.service.js';
 import { type ISchemaChangeApplied, type ISchemaChangePlan } from './schema-change.types.js';
+import { EntityBuilderConfigService } from './entity-builder-config.service.js';
 import { SchemaDialectAdapterService } from './schema-dialect-adapter.service.js';
 export type SchemaFindingKind = 'missing_table' | 'missing_column' | 'extra_column' | 'type_mismatch' | 'nullability_mismatch' | 'missing_index' | 'missing_unique' | 'stale_metadata';
 export interface ISchemaFinding extends IMessageRef {
@@ -28,13 +29,14 @@ export declare class SchemaEvolutionService {
     private readonly executor;
     private readonly references;
     private readonly permissions;
-    constructor(dataSourceProvider: EntityBuilderDataSourceProvider, adapter: SchemaDialectAdapterService, executor: SchemaChangeExecutor, references: ReferenceScannerService, permissions: EntityPermissionService);
+    private readonly config?;
+    constructor(dataSourceProvider: EntityBuilderDataSourceProvider, adapter: SchemaDialectAdapterService, executor: SchemaChangeExecutor, references: ReferenceScannerService, permissions: EntityPermissionService, config?: EntityBuilderConfigService | undefined);
     plan(request: SchemaChangeRequestDto, user: ILoggedUserInfo | null): Promise<ISchemaChangePlan>;
     apply(request: SchemaChangeRequestDto, user: ILoggedUserInfo | null, options?: {
         fieldId?: string;
     }): Promise<ISchemaChangeApplied>;
     inspect(entityDefinitionId: string): Promise<ISchemaCheckResult>;
-    history(entityDefinitionId: string, limit?: number): Promise<SchemaChangeLog[]>;
+    history(entityDefinitionId: string): Promise<SchemaChangeLog[]>;
     private loadEntity;
     private loadField;
     private definitions;
@@ -56,12 +58,16 @@ export declare class SchemaEvolutionService {
     private dropUniques;
     private hasUnique;
     private indexOn;
+    private liveOnly;
+    private hasPlainIndex;
+    private rebuildPlainIndex;
     private prepareAddField;
     private prepareUpdateField;
     private prepareDeprecateField;
     private prepareRestoreField;
     private preparePurgeField;
     private prepareUpdateEntity;
+    private reshapePlainIndexes;
     private relationsInto;
     private prepareDropEntity;
     private diff;

package/services/schema-registry.service.d.ts

@@ -1,12 +1,24 @@
 import { EntitySchema, type QueryRunner } from 'typeorm';
+import { EntityDefinition } from '../entities/entity-definition.entity.js';
+import { FieldDefinition } from '../entities/field-definition.entity.js';
 import { EntityBuilderDataSourceProvider } from './entity-builder-datasource.provider.js';
 import { SchemaDialectAdapterService } from './schema-dialect-adapter.service.js';
+export interface IResolvedSchema {
+    schema: EntitySchema;
+    fields: FieldDefinition[];
+}
 export declare class SchemaRegistryService {
     private readonly dataSourceProvider;
     private readonly dialectAdapter;
     private static readonly cache;
+    private static readonly warming;
+    private readonly logger;
     constructor(dataSourceProvider: EntityBuilderDataSourceProvider, dialectAdapter: SchemaDialectAdapterService);
     getSchema(entityDefinitionId: string, queryRunner?: QueryRunner): Promise<EntitySchema>;
+    resolve(definition: EntityDefinition, queryRunner?: QueryRunner): Promise<IResolvedSchema>;
+    warmUp(queryRunner?: QueryRunner): Promise<void>;
+    private registerAll;
+    private store;
     invalidate(entityDefinitionId: string): void;
     private cacheKey;
     private buildEntitySchema;

package/services/schema-sync.service.d.ts

@@ -6,6 +6,7 @@ import { EntityPermissionService } from './entity-permission.service.js';
 import { FlowDefinitionService } from './flow-definition.service.js';
 import { SchemaChangeExecutor } from './schema-change-executor.service.js';
 import { type ISchemaChangePlan } from './schema-change.types.js';
+import { EntityBuilderConfigService } from './entity-builder-config.service.js';
 import { SchemaDialectAdapterService } from './schema-dialect-adapter.service.js';
 export interface ICreatedEntity {
     definition: EntityDefinition;
@@ -21,8 +22,9 @@ export declare class SchemaSyncService {
     private readonly executor;
     private readonly entityPermissionService;
     private readonly flowDefinitionService;
+    private readonly config?;
     private readonly logger;
-    constructor(dataSourceProvider: EntityBuilderDataSourceProvider, dialectAdapter: SchemaDialectAdapterService, executor: SchemaChangeExecutor, entityPermissionService: EntityPermissionService, flowDefinitionService: FlowDefinitionService);
+    constructor(dataSourceProvider: EntityBuilderDataSourceProvider, dialectAdapter: SchemaDialectAdapterService, executor: SchemaChangeExecutor, entityPermissionService: EntityPermissionService, flowDefinitionService: FlowDefinitionService, config?: EntityBuilderConfigService | undefined);
     private validateCreateRequest;
     private createTarget;
     private createRun;

package/flow-engine/flow-code-sandbox.d.ts

@@ -1,5 +0,0 @@
-export interface ICodeRunResult {
-    output: unknown;
-    logs: string[];
-}
-export declare function runSandboxedCode(code: string, ctx: Record<string, unknown>, timeoutMs: number, node: string): Promise<ICodeRunResult>;