@flusys/nestjs-entity-builder 9.0.0

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

@@ -0,0 +1,38 @@
+import { FlowExecution } from '../entities/flow-execution.entity.js';
+import { type IFlowRunResult, type IFlowSavePoint } from '../flow-engine/flow-run.types.js';
+import { EntityBuilderDataSourceProvider } from './entity-builder-datasource.provider.js';
+export interface IExecutionRecord {
+    flowId: string | null;
+    flowSlug: string;
+    flowVersion: number | null;
+    trigger: 'webhook' | 'test';
+    mode: 'live' | 'dry_run';
+    input: unknown;
+    result: Pick<IFlowRunResult, 'status' | 'statusCode' | 'body' | 'error' | 'trace' | 'durationMs'>;
+    startedAt: Date;
+    actorId: string | null;
+    callerIp: string | null;
+    retain: number;
+}
+export declare const DRAFT_TEST_RETAIN = 200;
+export declare class FlowExecutionService {
+    private readonly provider;
+    private readonly logger;
+    private static writes;
+    constructor(provider: EntityBuilderDataSourceProvider);
+    record(entry: IExecutionRecord): Promise<void>;
+    prune(flowId: string | null, retain: number): Promise<void>;
+    list(query: {
+        flowId?: string;
+        status?: string;
+        page: number;
+        pageSize: number;
+    }): Promise<{
+        rows: FlowExecution[];
+        total: number;
+    }>;
+    get(id: string): Promise<(FlowExecution & {
+        savedUpTo: IFlowSavePoint | null;
+    }) | null>;
+    private repo;
+}

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

@@ -0,0 +1,41 @@
+import { type ICompanyAccessResolver, type IEmailAdapter, type ILoggedUserInfo, type INotificationAdapter } from '@flusys/nestjs-shared/interfaces';
+import { SharedPermissionCacheService } from '@flusys/nestjs-shared/modules';
+import { ModuleRef } from '@nestjs/core';
+import { type IFlowRunResult } from '../flow-engine/flow-run.types.js';
+import { type FlowInput, type FlowRunMode, type IFlowSettings } from '../flow-engine/flow.types.js';
+import { RuleEngineService } from '../rule-engine/index.js';
+import { EntityBuilderConfigService } from './entity-builder-config.service.js';
+import { EntityBuilderDataSourceProvider } from './entity-builder-datasource.provider.js';
+export interface IFlowRunOptions {
+    mode: FlowRunMode;
+    user: ILoggedUserInfo | null;
+    input: FlowInput;
+    startAt?: string;
+    request: Record<string, unknown>;
+    authorization?: string;
+    exposeDetails: boolean;
+    systemAuthorized: boolean;
+}
+export declare const flowTimeout: (timeoutMs: unknown) => number;
+export declare class FlowExecutorService {
+    private readonly provider;
+    private readonly ruleEngine;
+    private readonly moduleRef;
+    private readonly permissionCache;
+    private readonly config;
+    private readonly companyAccess?;
+    private readonly notifications?;
+    private readonly email?;
+    private readonly logger;
+    constructor(provider: EntityBuilderDataSourceProvider, ruleEngine: RuleEngineService, moduleRef: ModuleRef, permissionCache: SharedPermissionCacheService, config: EntityBuilderConfigService, companyAccess?: ICompanyAccessResolver | undefined, notifications?: INotificationAdapter | undefined, email?: IEmailAdapter | undefined);
+    run(flow: IFlowSettings, options: IFlowRunOptions): Promise<IFlowRunResult>;
+    private execute;
+    private limitStatementTime;
+    private commitProgress;
+    private atomic;
+    private callFlow;
+    private findCallable;
+    private assertMayCall;
+    private createEnv;
+    private publishPendingEvents;
+}

package/services/flow-reference.provider.d.ts

@@ -0,0 +1,13 @@
+import { type EntityManager } from 'typeorm';
+import { type IEntityReferenceProvider } from '../interfaces/reference-provider.interface.js';
+import { EntityBuilderDataSourceProvider } from './entity-builder-datasource.provider.js';
+import { type ISchemaImpact } from './schema-change.types.js';
+export declare class FlowReferenceProvider implements IEntityReferenceProvider {
+    private readonly provider;
+    constructor(provider: EntityBuilderDataSourceProvider);
+    private flows;
+    private repo;
+    findEntityReferences(entityCode: string): Promise<ISchemaImpact[]>;
+    findFieldReferences(entityCode: string, fieldCode: string): Promise<ISchemaImpact[]>;
+    rewriteFieldReferences(entityCode: string, from: string, to: string, manager?: EntityManager): Promise<number>;
+}

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

@@ -0,0 +1,30 @@
+import { type ILoggedUserInfo, type IMessageRef } from '@flusys/nestjs-shared/interfaces';
+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';
+import { type IFlowEndpoint } from '../flow-engine/flow.types.js';
+import { EntityBuilderDataSourceProvider } from './entity-builder-datasource.provider.js';
+import { FlowDefinitionService } from './flow-definition.service.js';
+import { FlowExecutionService } from './flow-execution.service.js';
+import { FlowExecutorService } from './flow-executor.service.js';
+export interface IFlowCaller {
+    ip: string | null;
+    headers: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    path?: string | null;
+}
+export declare function requestInfo(caller: IFlowCaller): Record<string, unknown>;
+export declare class FlowRuntimeService {
+    private readonly provider;
+    private readonly executor;
+    private readonly executions;
+    private readonly definitions;
+    constructor(provider: EntityBuilderDataSourceProvider, executor: FlowExecutorService, executions: FlowExecutionService, definitions: FlowDefinitionService);
+    findActive(slug: string): Promise<FlowDefinition | null>;
+    handle(flow: FlowDefinition, endpoint: IFlowEndpoint, body: unknown, caller: IFlowCaller, user: ILoggedUserInfo | null): Promise<IFlowRunResult>;
+    testRun(dto: TestFlowDto, user: ILoggedUserInfo | null, caller: IFlowCaller): Promise<{
+        result: IFlowRunResult;
+        warnings: IMessageRef[];
+    }>;
+    private logWebhook;
+}

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

@@ -0,0 +1,12 @@
+import { type QueryRunner } from 'typeorm';
+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);
+    forEntityCode(entityCode: string, queryRunner?: QueryRunner): Promise<GenericEntityService>;
+    forEntityDefinitionId(entityDefinitionId: string, queryRunner?: QueryRunner): Promise<GenericEntityService>;
+    private build;
+}

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

@@ -0,0 +1,67 @@
+import { type ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
+import { type EntitySchema, type QueryRunner } from 'typeorm';
+import { EntityDefinition } from '../entities/entity-definition.entity.js';
+import { FieldDefinition } from '../entities/field-definition.entity.js';
+import { type IGenericRecord } from '../interfaces/generic-record.interface.js';
+import { EntityBuilderDataSourceProvider } from './entity-builder-datasource.provider.js';
+export interface IGenericReadOptions {
+    queryRunner?: QueryRunner;
+}
+export interface IGenericQuery {
+    filter?: Record<string, unknown>;
+    sort?: Record<string, 'ASC' | 'DESC'>;
+    pagination?: {
+        currentPage: number;
+        pageSize: number;
+    };
+}
+export interface IGenericWriteOptions {
+    queryRunner?: QueryRunner;
+    publishEvents?: boolean;
+}
+export declare const ACTOR_BRANCH_METADATA_KEY = "_actorBranchId";
+export declare function actorMetadata(user: ILoggedUserInfo | null): Record<string, unknown>;
+export type RelatedServiceResolver = (entityDefinitionId: string, queryRunner?: QueryRunner) => Promise<GenericEntityService>;
+export declare class GenericEntityService {
+    private readonly definition;
+    private readonly schema;
+    private readonly fields;
+    private readonly dataSourceProvider;
+    private readonly resolveRelated?;
+    private repository?;
+    private readonly activeFieldCodes;
+    private readonly presentSystemColumns;
+    constructor(definition: EntityDefinition, schema: EntitySchema, fields: FieldDefinition[], dataSourceProvider: EntityBuilderDataSourceProvider, resolveRelated?: RelatedServiceResolver | undefined);
+    get entityCode(): string;
+    private validateValues;
+    private throwIfInvalid;
+    private assertRelationsExist;
+    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>;
+    update(dto: Record<string, unknown> & {
+        id: string;
+    }, user: ILoggedUserInfo | null, options?: IGenericWriteOptions): Promise<IGenericRecord>;
+    private insertRow;
+    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>;
+    getAll(search: string | undefined, query: IGenericQuery, options?: IGenericReadOptions): Promise<{
+        data: IGenericRecord[];
+        total: number;
+    }>;
+    private applyFilter;
+    private unknownOperator;
+    private invalidFilterValue;
+    private applySort;
+    private applySearch;
+    private assertKnownColumn;
+    private withTransaction;
+}

package/services/identifier-rules.d.ts

@@ -0,0 +1,9 @@
+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;
+    fieldType: FieldType;
+    unique?: boolean | null;
+    isIndexed?: boolean | null;
+}): void;

package/services/index.d.ts

@@ -0,0 +1,26 @@
+export * from './entity-builder-config.service.js';
+export * from './entity-builder-datasource.provider.js';
+export * from './schema-dialect-adapter.service.js';
+export * from './schema-registry.service.js';
+export * from './schema-sync.service.js';
+export * from './entity-definition.service.js';
+export * from './field-definition.service.js';
+export * from './generic-entity.service.js';
+export * from './generic-entity-service.factory.js';
+export * from './entity-permission.service.js';
+export * from './definition-cache.service.js';
+export * from './schema-change-executor.service.js';
+export * from './schema-change.types.js';
+export * from './schema-columns.js';
+export * from './field-type-conversion.js';
+export * from './identifier-rules.js';
+export * from './schema-evolution.service.js';
+export * from './reference-scanner.service.js';
+export * from './field-value-validator.js';
+export * from './database-error.mapper.js';
+export * from './flow-definition.service.js';
+export * from './flow-execution.service.js';
+export * from './flow-executor.service.js';
+export * from './flow-runtime.service.js';
+export * from './flow-reference.provider.js';
+export * from './entity-flow-scaffold.js';

package/services/reference-rewrite.d.ts

@@ -0,0 +1,7 @@
+type Json = unknown;
+export declare function mapStrings(value: Json, fn: (s: string) => string): Json;
+export declare function anyString(value: Json, test: (s: string) => boolean): boolean;
+export declare const escapeRe: (s: string) => string;
+export declare const referencePatternSource: (prefixSource: string, field: string, flags?: string) => RegExp;
+export declare const replaceReferenceSource: (s: string, prefixSource: string, from: string, to: string) => string;
+export {};

package/services/reference-scanner.service.d.ts

@@ -0,0 +1,10 @@
+import { type EntityManager } from 'typeorm';
+import { type IEntityReferenceProvider } from '../interfaces/reference-provider.interface.js';
+import { type ISchemaImpact } from './schema-change.types.js';
+export declare class ReferenceScannerService {
+    private readonly flowReferences?;
+    constructor(flowReferences?: IEntityReferenceProvider | undefined);
+    forEntity(entityCode: string): Promise<ISchemaImpact[]>;
+    forField(entityCode: string, fieldCode: string): Promise<ISchemaImpact[]>;
+    rewriteFieldCode(entityCode: string, from: string, to: string, manager?: EntityManager): Promise<number>;
+}

package/services/schema-change-executor.service.d.ts

@@ -0,0 +1,39 @@
+import { type ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
+import { DefinitionCacheService } from './definition-cache.service.js';
+import { EntityBuilderDataSourceProvider } from './entity-builder-datasource.provider.js';
+import { SchemaDialectAdapterService } from './schema-dialect-adapter.service.js';
+import { SchemaRegistryService } from './schema-registry.service.js';
+import { type ISchemaChangeOutcome, type ISchemaChangePlan, type ISchemaImpact, type SchemaChangeRun } from './schema-change.types.js';
+export interface ISchemaChangeTarget {
+    action: string;
+    entityDefinitionId: string | null;
+    entityCode: string;
+    tableName: string;
+    user: ILoggedUserInfo | null;
+    lockCodes?: string[];
+}
+export interface IApplyOptions {
+    confirm?: boolean;
+    impact?: ISchemaImpact[];
+}
+export declare function relationTargetCodes(provider: EntityBuilderDataSourceProvider, ids: Array<string | null | undefined>): Promise<string[]>;
+export declare class SchemaChangeExecutor {
+    private readonly dataSourceProvider;
+    private readonly dialectAdapter;
+    private readonly schemaRegistry;
+    private readonly definitionCache;
+    private readonly logger;
+    constructor(dataSourceProvider: EntityBuilderDataSourceProvider, dialectAdapter: SchemaDialectAdapterService, schemaRegistry: SchemaRegistryService, definitionCache: DefinitionCacheService);
+    simulate(target: ISchemaChangeTarget, run: SchemaChangeRun, impact?: ISchemaImpact[]): Promise<ISchemaChangePlan>;
+    apply(target: ISchemaChangeTarget, run: SchemaChangeRun, options?: IApplyOptions): Promise<{
+        plan: ISchemaChangePlan;
+        outcome: ISchemaChangeOutcome;
+    }>;
+    private compensate;
+    private withUndo;
+    private logFailure;
+    private operationFor;
+    private newState;
+    private toPlan;
+    private buildContext;
+}

package/services/schema-change.types.d.ts

@@ -0,0 +1,59 @@
+import { type IMessageRef } from '@flusys/nestjs-shared/interfaces';
+import { type QueryRunner } from 'typeorm';
+import { type DdlOperation } from '../enums/ddl-operation.enum.js';
+import { type SupportedDbDriver } from '../interfaces/schema-dialect-adapter.interface.js';
+export interface IPlanStep {
+    description: IMessageRef;
+    sql: string[];
+}
+export declare const describeImpact: (impact: ISchemaImpact[]) => string;
+export interface ISchemaImpact {
+    kind: 'flow';
+    id: string;
+    name: string;
+    detail: IMessageRef;
+}
+export interface ISchemaChangePlan {
+    action: string;
+    entityCode: string;
+    tableName: string;
+    steps: IPlanStep[];
+    downSql: string[];
+    warnings: IMessageRef[];
+    blockers: IMessageRef[];
+    impact: ISchemaImpact[];
+    affectedRows: number | null;
+    destructive: boolean;
+    metadataOnly: boolean;
+}
+export interface ISchemaChangeApplied extends ISchemaChangePlan {
+    result: Record<string, unknown>;
+}
+export interface ISchemaUndoReport {
+    reverted: boolean;
+    pendingSql: string[];
+    dataNotReverted: boolean;
+}
+export interface ISchemaChangeContext {
+    readonly qr: QueryRunner;
+    readonly driver: SupportedDbDriver;
+    readonly blocked: boolean;
+    q(identifier: string): string;
+    ddl(description: IMessageRef, fn: () => Promise<void>): Promise<void>;
+    rawDdl(description: IMessageRef, sql: string[], downSql?: string[]): Promise<void>;
+    data(description: IMessageRef, sqlPreview: string, fn: () => Promise<void>): Promise<void>;
+    metadata(fn: () => Promise<void>): Promise<void>;
+    warn(message: IMessageRef): void;
+    block(message: IMessageRef): void;
+    setAffectedRows(count: number): void;
+    markDestructive(): void;
+}
+export interface ISchemaChangeOutcome {
+    operation: DdlOperation;
+    entityDefinitionId?: string | null;
+    fieldDefinitionId?: string | null;
+    diff: Record<string, unknown>;
+    bumpVersion?: boolean;
+    afterCommit?: () => Promise<void>;
+}
+export type SchemaChangeRun = (ctx: ISchemaChangeContext) => Promise<ISchemaChangeOutcome>;

package/services/schema-columns.d.ts

@@ -0,0 +1,26 @@
+import { type QueryRunner, type Table, TableColumn, TableIndex, TableUnique } from 'typeorm';
+import { type FieldDefinition } from '../entities/field-definition.entity.js';
+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 isIndexableFieldType: (fieldType: FieldType) => boolean;
+export interface ISystemColumnFlags {
+    isSoftDeleteEnabled: boolean;
+    isAuditEnabled: boolean;
+}
+export declare function buildSystemColumns(flags: ISystemColumnFlags, driver: SupportedDbDriver): TableColumn[];
+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 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: {
+    enforceNotNull: boolean;
+    withUnique: boolean;
+}): TableColumn;
+export declare function sqlTypeFor(fieldType: FieldType, driver: SupportedDbDriver, adapter: SchemaDialectAdapterService): string;
+export declare function typeFamily(type: string): string;

package/services/schema-dialect-adapter.service.d.ts

@@ -0,0 +1,13 @@
+import { type ColumnType, type QueryRunner } from 'typeorm';
+import { FieldType } from '../enums/field-type.enum.js';
+import { type IColumnSizing, type ISchemaDialectAdapter, type SupportedDbDriver } from '../interfaces/schema-dialect-adapter.interface.js';
+export declare function fitIdentifier(text: string, max: number): string;
+export declare class SchemaDialectAdapterService implements ISchemaDialectAdapter {
+    mapFieldType(fieldType: FieldType, driver: SupportedDbDriver): ColumnType;
+    getColumnSizing(fieldType: FieldType, driver?: SupportedDbDriver): IColumnSizing;
+    maxIdentifierLength(driver: SupportedDbDriver): number;
+    sqlLiteral(value: unknown, driver: SupportedDbDriver): string;
+    lockName(lockKey: string): string;
+    acquireEntityLock(queryRunner: QueryRunner, lockKey: string, driver: SupportedDbDriver): Promise<void>;
+    releaseEntityLock(queryRunner: QueryRunner, lockKey: string, driver: SupportedDbDriver): Promise<void>;
+}

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

@@ -0,0 +1,67 @@
+import { type ILoggedUserInfo, type IMessageRef } from '@flusys/nestjs-shared/interfaces';
+import { SchemaChangeAction, type SchemaChangeRequestDto } from '../dtos/schema-change.dto.js';
+import { SchemaChangeLog } from '../entities/schema-change-log.entity.js';
+import { EntityBuilderDataSourceProvider } from './entity-builder-datasource.provider.js';
+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 { 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 {
+    kind: SchemaFindingKind;
+    severity: 'error' | 'warning';
+    field?: string;
+    repairable: boolean;
+}
+export interface ISchemaCheckResult {
+    entityCode: string;
+    tableName: string;
+    healthy: boolean;
+    rowCount: number | null;
+    findings: ISchemaFinding[];
+}
+export declare const isDestructiveSchemaAction: (action: SchemaChangeAction) => boolean;
+export declare class SchemaEvolutionService {
+    private readonly dataSourceProvider;
+    private readonly adapter;
+    private readonly executor;
+    private readonly references;
+    private readonly permissions;
+    constructor(dataSourceProvider: EntityBuilderDataSourceProvider, adapter: SchemaDialectAdapterService, executor: SchemaChangeExecutor, references: ReferenceScannerService, permissions: EntityPermissionService);
+    plan(request: SchemaChangeRequestDto, user: ILoggedUserInfo | null): Promise<ISchemaChangePlan>;
+    apply(request: SchemaChangeRequestDto, user: ILoggedUserInfo | null): Promise<ISchemaChangeApplied>;
+    inspect(entityDefinitionId: string): Promise<ISchemaCheckResult>;
+    history(entityDefinitionId: string, limit?: number): Promise<SchemaChangeLog[]>;
+    private loadEntity;
+    private loadField;
+    private definitions;
+    private rejectUnknownKeys;
+    private validateChanges;
+    private current;
+    private assertNotStale;
+    private changedUnderneath;
+    private prepare;
+    private target;
+    private scalar;
+    private advisoryScalar;
+    private paramValue;
+    private notNullSql;
+    private setRequired;
+    private checkValue;
+    private requireTable;
+    private countDuplicates;
+    private dropUniques;
+    private hasUnique;
+    private indexOn;
+    private prepareAddField;
+    private prepareUpdateField;
+    private prepareDeprecateField;
+    private prepareRestoreField;
+    private preparePurgeField;
+    private prepareUpdateEntity;
+    private relationsInto;
+    private prepareDropEntity;
+    private diff;
+    private prepareRepair;
+}

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

@@ -0,0 +1,13 @@
+import { EntitySchema, type QueryRunner } from 'typeorm';
+import { EntityBuilderDataSourceProvider } from './entity-builder-datasource.provider.js';
+import { SchemaDialectAdapterService } from './schema-dialect-adapter.service.js';
+export declare class SchemaRegistryService {
+    private readonly dataSourceProvider;
+    private readonly dialectAdapter;
+    private static readonly cache;
+    constructor(dataSourceProvider: EntityBuilderDataSourceProvider, dialectAdapter: SchemaDialectAdapterService);
+    getSchema(entityDefinitionId: string, queryRunner?: QueryRunner): Promise<EntitySchema>;
+    invalidate(entityDefinitionId: string): void;
+    private cacheKey;
+    private buildEntitySchema;
+}

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

@@ -0,0 +1,28 @@
+import { type ILoggedUserInfo, type IMessageRef } from '@flusys/nestjs-shared/interfaces';
+import { CreateDynamicEntityDto } from '../dtos/index.js';
+import { EntityDefinition } from '../entities/entity-definition.entity.js';
+import { EntityBuilderDataSourceProvider } from './entity-builder-datasource.provider.js';
+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 { SchemaDialectAdapterService } from './schema-dialect-adapter.service.js';
+export interface ICreatedEntity {
+    definition: EntityDefinition;
+    warnings: IMessageRef[];
+}
+export declare class SchemaSyncService {
+    private readonly dataSourceProvider;
+    private readonly dialectAdapter;
+    private readonly executor;
+    private readonly entityPermissionService;
+    private readonly flowDefinitionService;
+    private readonly logger;
+    constructor(dataSourceProvider: EntityBuilderDataSourceProvider, dialectAdapter: SchemaDialectAdapterService, executor: SchemaChangeExecutor, entityPermissionService: EntityPermissionService, flowDefinitionService: FlowDefinitionService);
+    private validateCreateRequest;
+    private createTarget;
+    private createRun;
+    private createEndpointFlow;
+    planCreateEntity(dto: CreateDynamicEntityDto, user: ILoggedUserInfo | null): Promise<ISchemaChangePlan>;
+    createEntity(dto: CreateDynamicEntityDto, user: ILoggedUserInfo | null): Promise<ICreatedEntity>;
+}