@flusys/nestjs-entity-builder 9.1.0 → 9.1.1

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

@@ -0,0 +1,111 @@
+import { type IMessageRef } from '@flusys/nestjs-shared/interfaces';
+import { type EntityStatus } from '../enums/entity-status.enum.js';
+import { type FieldType } from '../enums/field-type.enum.js';
+import { type IFlowSnapshot } from './flow-definition.interface.js';
+import { type ISchemaChangePlan } from '../services/schema-change.types.js';
+export declare const DEFINITION_BUNDLE_FORMAT = "flusys.entity-builder.bundle";
+export declare const DEFINITION_BUNDLE_VERSION = 1;
+export interface IBundleField {
+    id: string;
+    code: string;
+    label: string;
+    fieldType: FieldType;
+    nullable: boolean;
+    unique: boolean;
+    isIndexed: boolean;
+    defaultValue: unknown;
+    validationRules: Record<string, unknown> | null;
+    selectOptions: unknown[] | null;
+    relationTarget: string | null;
+    order: number;
+    uiConfig: Record<string, unknown> | null;
+    isSearchable: boolean;
+    deprecated: boolean;
+}
+export interface IBundleEntity {
+    id: string;
+    code: string;
+    label: string;
+    description: string | null;
+    status: EntityStatus;
+    isSoftDeleteEnabled: boolean;
+    isAuditEnabled: boolean;
+    uiConfig: Record<string, unknown> | null;
+    fields: IBundleField[];
+}
+export type IBundleFlow = IFlowSnapshot;
+export interface IDefinitionBundle {
+    format: typeof DEFINITION_BUNDLE_FORMAT;
+    version: typeof DEFINITION_BUNDLE_VERSION;
+    entities: IBundleEntity[];
+    flows: IBundleFlow[];
+}
+export interface IImportBundleRequest {
+    bundle: IDefinitionBundle;
+    deprecateMissingFields?: boolean;
+    confirm?: boolean;
+    expectedChecksum?: string;
+    expectedPlanChecksum?: string;
+}
+export interface IBundleExport {
+    bundle: IDefinitionBundle;
+    checksum: string;
+    warnings: IMessageRef[];
+}
+export type BundleStepKind = 'update_entity' | 'create_entity' | 'restore_field' | 'rename_field' | 'update_field' | 'add_field' | 'deprecate_field' | 'create_flow' | 'update_flow';
+export interface IBundleStep {
+    kind: BundleStepKind;
+    entityCode?: string;
+    fieldCode?: string;
+    flowSlug?: string;
+    details: Record<string, unknown>;
+    preview: ISchemaChangePlan | null;
+    warnings: IMessageRef[];
+    blockers: IMessageRef[];
+}
+export interface IBundleExtra {
+    kind: 'entity' | 'field' | 'flow';
+    entityCode?: string;
+    fieldCode?: string;
+    flowSlug?: string;
+}
+export interface IBundleImportPlan {
+    checksum: string;
+    planChecksum: string;
+    steps: IBundleStep[];
+    unchanged: {
+        entities: number;
+        fields: number;
+        flows: number;
+    };
+    extras: IBundleExtra[];
+    blockers: IMessageRef[];
+    destructive: boolean;
+    mayLoseData: boolean;
+}
+export interface IBundleSettings {
+    readOnly: boolean;
+    variables: string[];
+}
+export interface IGeneratedApiKey {
+    flowSlug: string;
+    nodeId: string;
+    path: string | null;
+    key: string;
+}
+export interface IBundleStepResult {
+    kind: BundleStepKind;
+    entityCode?: string;
+    fieldCode?: string;
+    flowSlug?: string;
+    status: 'applied' | 'failed' | 'skipped';
+    error?: IMessageRef;
+    blockers?: IMessageRef[];
+}
+export interface IBundleImportResult {
+    checksum: string;
+    completed: boolean;
+    steps: IBundleStepResult[];
+    apiKeys: IGeneratedApiKey[];
+    warnings: IMessageRef[];
+}

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

@@ -6,6 +6,12 @@ export interface IEntityBuilderConfig extends IDataSourceServiceOptions {
     flows?: {
         allowPrivateHttp?: boolean;
     };
+    bundles?: {
+        variables?: Record<string, string>;
+    };
+    designer?: {
+        readOnly?: boolean;
+    };
 }
 export interface EntityBuilderModuleOptions extends IDynamicModuleConfig {
     bootstrapAppConfig?: IBootstrapAppConfig;

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

@@ -1,20 +1,24 @@
 import { type IIdentity } from '@flusys/nestjs-shared/interfaces';
-import { type FlowAuthMode, type FlowBodyType, type FlowRunAs, type IFlowEdge, type IFlowInputField, type IFlowNode } from '../flow-engine/flow.types.js';
+import { type IFlowEdge, type IFlowNode } from '../flow-engine/flow.types.js';
 export interface IFlowDefinition extends IIdentity {
     name: string;
     slug: string;
     description: string | null;
     isActive: boolean;
-    authMode: FlowAuthMode;
-    permissionCode: string | null;
-    runAs: FlowRunAs;
-    isTransactional: boolean;
-    timeoutMs: number;
-    rateLimitPerMinute: number;
     retainExecutions: number;
-    bodyType: FlowBodyType;
-    inputSchema: IFlowInputField[];
     nodes: IFlowNode[];
     edges: IFlowEdge[];
     version: number;
+    draft: IFlowSnapshot | null;
+}
+export declare const FLOW_VERSIONED_FIELDS: readonly ["name", "slug", "description", "isActive", "retainExecutions", "nodes", "edges"];
+export type IFlowSnapshot = Pick<IFlowDefinition, (typeof FLOW_VERSIONED_FIELDS)[number]>;
+export interface IFlowVersion {
+    id: string;
+    flowId: string;
+    version: number;
+    note: string | null;
+    publishedAt: Date;
+    publishedById: string | null;
+    definition?: IFlowSnapshot;
 }

package/interfaces/index.d.ts

@@ -3,3 +3,4 @@ export * from './entity-builder-module.interface.js';
 export * from './schema-dialect-adapter.interface.js';
 export * from './generic-record.interface.js';
 export * from './reference-provider.interface.js';
+export * from './definition-bundle.interface.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flusys/nestjs-entity-builder",
-  "version": "9.1.0",
+  "version": "9.1.1",
   "description": "Dynamic entity builder module - runtime entity/field metadata, driven DDL, and generic CRUD",
   "type": "module",
   "main": "./fesm/index.js",
@@ -75,18 +75,18 @@
     "@nestjs/common": "^12.0.0",
     "@nestjs/config": "^12.0.0",
     "@nestjs/core": "^12.0.0",
-    "@nestjs/platform-express": "^12.0.0",
+    "@nestjs/platform-express": "^12.1.2",
     "@nestjs/swagger": "^12.0.0",
     "@nestjs/typeorm": "^12.0.0",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.15.0",
-    "typeorm": "^0.3.0",
+    "typeorm": "^0.3.31",
     "express": "^5.0.0",
     "rxjs": "^7.8.0"
   },
   "dependencies": {
-    "@flusys/nestjs-core": "9.1.0",
-    "@flusys/nestjs-shared": "9.1.0",
+    "@flusys/nestjs-core": "9.1.1",
+    "@flusys/nestjs-shared": "9.1.1",
     "re2js": "^2.8.6",
     "quickjs-emscripten": "^0.32.0"
   }

package/rule-engine/rule-engine.service.d.ts

@@ -17,6 +17,7 @@ export declare class RuleEngineService {
     private resolveConditionLeft;
     private resolveConditionValue;
     resolveExpression(expression: RuleExpression, ctx: RuleEvaluationContext, budget?: IEvaluationBudget): Promise<unknown>;
+    resolveHtml(expression: RuleExpression, ctx: RuleEvaluationContext): Promise<unknown>;
     private resolveLookup;
     private resolveTemplate;
     private resolveFieldReference;

package/rule-engine/rule-permission.d.ts

@@ -1,10 +1,6 @@
-import { type ILoggedUserInfo, type IPermissionResolver } from '@flusys/nestjs-shared/interfaces';
-import { type SharedPermissionCacheService } from '@flusys/nestjs-shared/modules';
+import { type ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
+import { type IPermissionSources } from '@flusys/nestjs-shared/utils';
 import { type IRulePermissionResolver } from './rule-evaluation-context.interface.js';
-export interface IRulePermissionSources {
-    resolver?: IPermissionResolver;
-    cache?: SharedPermissionCacheService;
-}
-export declare function createRulePermissionResolver(user: ILoggedUserInfo | null, sources: IRulePermissionSources): IRulePermissionResolver;
+export declare function createRulePermissionResolver(user: ILoggedUserInfo | null, sources: IPermissionSources): IRulePermissionResolver;
 export declare function parsePermissionCodes(value: unknown): string[];
 export declare function toBranchArgument(args: unknown[], index: number): string | null | undefined;

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

@@ -0,0 +1,62 @@
+import { type IMessageRef } from '@flusys/nestjs-shared/interfaces';
+import { EntityStatus } from '../enums/entity-status.enum.js';
+import { type IFlowNode } from '../flow-engine/flow.types.js';
+import { type BundleStepKind, type IBundleEntity, type IBundleExtra, type IBundleField, type IBundleFlow, type IDefinitionBundle } from '../interfaces/definition-bundle.interface.js';
+export declare function canonicalJson(value: unknown): string;
+export declare const byCode: (a: string, b: string) => number;
+export declare const bundleSubject: (item: {
+    entityCode?: string;
+    fieldCode?: string;
+    flowSlug?: string;
+}) => string;
+export declare const bundleChecksum: (bundle: IDefinitionBundle) => string;
+export declare function stripApiKeys(nodes: IFlowNode[]): IFlowNode[];
+export declare function extractVariables(nodes: IFlowNode[], variables: Record<string, string>): IFlowNode[];
+export declare function applyVariables(nodes: IFlowNode[], variables: Record<string, string>): {
+    nodes: IFlowNode[];
+    missing: string[];
+};
+export declare function calledFlowSlugs(nodes: IFlowNode[]): string[];
+export declare function orderFlows(flows: IBundleFlow[]): IBundleFlow[];
+export interface ICurrentEntity {
+    id: string;
+    code: string;
+    label: string;
+    description: string | null;
+    status: EntityStatus;
+    isSoftDeleteEnabled: boolean;
+    isAuditEnabled: boolean;
+    uiConfig: Record<string, unknown> | null;
+    fields: IBundleField[];
+}
+export interface IPlannedOperation {
+    kind: BundleStepKind;
+    entityCode: string;
+    fieldCode?: string;
+    details: Record<string, unknown>;
+    dependsOnEarlierStep: boolean;
+    entity?: IBundleEntity;
+    field?: IBundleField;
+    targetFieldId?: string;
+    changes?: Record<string, unknown>;
+    warnings?: IMessageRef[];
+}
+export interface IEntityDiff {
+    operations: IPlannedOperation[];
+    unchangedEntities: number;
+    unchangedFields: number;
+    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;
+}, C extends {
+    id: string;
+    code: string;
+}>(items: B[], current: C[]): Map<B, C>;
+export declare function diffEntities(entities: IBundleEntity[], current: ICurrentEntity[], options?: {
+    deprecateMissingFields?: boolean;
+}): IEntityDiff;

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

@@ -0,0 +1,7 @@
+import { type IDefinitionBundle } from '../interfaces/definition-bundle.interface.js';
+export interface IUploadedBundleFile {
+    buffer: Buffer;
+    size: number;
+    originalname?: string;
+}
+export declare function readBundleFile(file: IUploadedBundleFile | undefined): IDefinitionBundle;

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

@@ -0,0 +1,32 @@
+import { type ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
+import { type ExportBundleDto } from '../dtos/definition-bundle.dto.js';
+import { type IBundleExport, type IBundleImportPlan, type IBundleImportResult, type IImportBundleRequest } from '../interfaces/definition-bundle.interface.js';
+import { EntityBuilderConfigService } from './entity-builder-config.service.js';
+import { EntityBuilderDataSourceProvider } from './entity-builder-datasource.provider.js';
+import { FlowDefinitionService } from './flow-definition.service.js';
+import { SchemaEvolutionService } from './schema-evolution.service.js';
+import { SchemaSyncService } from './schema-sync.service.js';
+export declare class DefinitionBundleService {
+    private readonly provider;
+    private readonly config;
+    private readonly schemaSync;
+    private readonly evolution;
+    private readonly flows;
+    constructor(provider: EntityBuilderDataSourceProvider, config: EntityBuilderConfigService, schemaSync: SchemaSyncService, evolution: SchemaEvolutionService, flows: FlowDefinitionService);
+    private variables;
+    export(dto: ExportBundleDto): Promise<IBundleExport>;
+    private loadEntities;
+    planImport(dto: IImportBundleRequest, user: ILoggedUserInfo | null): Promise<IBundleImportPlan>;
+    private buildPlan;
+    private relationNotYetCreated;
+    private previewEntityStep;
+    private diffFlows;
+    private fieldSpec;
+    private createRequest;
+    private changeRequest;
+    applyImport(dto: IImportBundleRequest, user: ILoggedUserInfo | null): Promise<IBundleImportResult>;
+    private applyEntityStep;
+    private idIsFree;
+    private freeFieldIds;
+    private applyFlowStep;
+}

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

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

package/services/entity-flow-scaffold.d.ts

@@ -8,6 +8,7 @@ export interface IEntityFlowField {
     nullable?: boolean;
     defaultValue?: unknown;
     selectOptions?: unknown[] | null;
+    validationRules?: Record<string, unknown> | null;
 }
 export interface IEntityFlowSource {
     code: string;
@@ -21,7 +22,6 @@ export interface IEntityFlowTexts {
     noMatchMessage?: string;
 }
 export declare const ENTITY_FLOW_PATHS: Record<EntityFlowEndpoint, string>;
-export declare const BULK_MAX_ITEMS = 200;
 export declare const entityFlowSlug: (entityCode: string) => string;
 export declare function buildEntityFlow(entity: IEntityFlowSource, endpoints: readonly EntityFlowEndpoint[], texts?: IEntityFlowTexts): CreateFlowDefinitionDto;
 export {};

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

@@ -1,41 +1,47 @@
 import { type IPermissionActionRegistry } from '@flusys/nestjs-shared';
 import { ApiService, HybridCache } from '@flusys/nestjs-shared/classes';
 import { type DeleteDto } from '@flusys/nestjs-shared/dtos';
-import { type ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
+import { type ICompanyAccessResolver, type IEmailAdapter, type ILogicNode, type ILoggedUserInfo, type INotificationAdapter } from '@flusys/nestjs-shared/interfaces';
 import { SharedPermissionCacheService, UtilsService } from '@flusys/nestjs-shared/modules';
 import { NotFoundException } from '@nestjs/common';
 import { type QueryRunner } from 'typeorm';
 import { type CreateFlowDefinitionDto, type UpdateFlowDefinitionDto } from '../dtos/flow.dto.js';
 import { FlowDefinition } from '../entities/flow-definition.entity.js';
 import { type IFlowValidationResult } from '../flow-engine/flow-graph.validator.js';
-import { type IFlowSettings } from '../flow-engine/flow.types.js';
-import { type IFlowDefinition } from '../interfaces/flow-definition.interface.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 { 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;
 export declare const flowNotFound: () => NotFoundException;
-export declare function toFlowSettings(dto: Pick<Partial<CreateFlowDefinitionDto>, 'authMode' | 'runAs' | 'isTransactional' | 'bodyType' | 'inputSchema' | 'nodes' | 'edges' | 'timeoutMs'> & {
+export declare const isPublished: (flow: Pick<FlowDefinition, "version">) => boolean;
+export declare function snapshotOf(source: Partial<IFlowSnapshot>): IFlowSnapshot;
+export declare const workingCopy: (flow: FlowDefinition) => IFlowSnapshot;
+type FlowSettingsSource = Pick<Partial<CreateFlowDefinitionDto>, 'nodes' | 'edges'> & {
     slug: string;
-}): IFlowSettings & {
-    timeoutMs: number;
 };
+export declare function toFlowSettings(dto: FlowSettingsSource): IFlowSettings;
 export declare class FlowDefinitionService extends ApiService<CreateFlowDefinitionDto, UpdateFlowDefinitionDto, IFlowDefinition, FlowDefinition> {
     protected cacheManager: HybridCache;
     protected utilsService: UtilsService;
     private readonly provider;
     private readonly permissionCache;
     private readonly actionRegistry?;
-    constructor(cacheManager: HybridCache, utilsService: UtilsService, provider: EntityBuilderDataSourceProvider, permissionCache: SharedPermissionCacheService, actionRegistry?: IPermissionActionRegistry | undefined);
+    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);
     findOrFail(id: string): Promise<FlowDefinition>;
     validate(settings: IFlowSettings): Promise<IFlowValidationResult>;
     private callersOf;
     private assertNotCalled;
+    private assertCallersKept;
+    private assertCallsStillValid;
     private assertEndpointsNotCalled;
     private assertSaveable;
     assertMayAuthor(settings: IFlowSettings, user: ILoggedUserInfo | null): Promise<void>;
     assertMayCreate(user: ILoggedUserInfo | null): Promise<void>;
-    assertMayTest(settings: IFlowSettings & {
-        permissionCode?: string | null;
-    }, user: ILoggedUserInfo | null, run: {
+    assertMayTest(settings: IFlowSettings, endpoint: IFlowEndpoint | undefined, user: ILoggedUserInfo | null, run: {
         mode: 'dry_run' | 'live';
         draft: boolean;
         saved: boolean;
@@ -43,8 +49,15 @@ export declare class FlowDefinitionService extends ApiService<CreateFlowDefiniti
     private assertHasPermission;
     protected beforeInsertOperation(dto: CreateFlowDefinitionDto | CreateFlowDefinitionDto[], user: ILoggedUserInfo | null, _qr: QueryRunner): Promise<void>;
     protected beforeUpdateOperation(dto: UpdateFlowDefinitionDto | UpdateFlowDefinitionDto[], user: ILoggedUserInfo | null, _qr: QueryRunner): Promise<void>;
+    protected convertSingleDtoToEntity(dto: CreateFlowDefinitionDto | UpdateFlowDefinitionDto, user: ILoggedUserInfo | null): Promise<FlowDefinition>;
+    publish(id: string, note: string | undefined, user: ILoggedUserInfo | null): Promise<FlowDefinition>;
+    listVersions(flowId: string): Promise<IFlowVersion[]>;
+    getVersion(flowId: string, version: number): Promise<IFlowVersion>;
+    restoreVersion(flowId: string, version: number, user: ILoggedUserInfo | null): Promise<FlowDefinition>;
+    discardDraft(flowId: string, user: ILoggedUserInfo | null): Promise<FlowDefinition>;
+    private saveDraft;
+    private clearCaches;
     protected beforeDeleteOperation(dto: DeleteDto, user: ILoggedUserInfo | null, _qr: QueryRunner): Promise<void>;
-    protected afterInsertOperation(entities: FlowDefinition[]): Promise<void>;
-    protected afterUpdateOperation(entities: FlowDefinition[]): Promise<void>;
     private provisionPermissions;
 }
+export {};

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

@@ -4,7 +4,12 @@ import { EntityBuilderDataSourceProvider } from './entity-builder-datasource.pro
 export interface IExecutionRecord {
     flowId: string | null;
     flowSlug: string;
+    flowVersion: number | null;
     trigger: 'webhook' | 'test';
+    endpoint: {
+        nodeId: string;
+        path: string | null;
+    } | null;
     mode: 'live' | 'dry_run';
     input: unknown;
     result: Pick<IFlowRunResult, 'status' | 'statusCode' | 'body' | 'error' | 'trace' | 'durationMs'>;
@@ -24,6 +29,8 @@ export declare class FlowExecutionService {
     list(query: {
         flowId?: string;
         status?: string;
+        trigger?: string;
+        endpointNodeId?: string;
         page: number;
         pageSize: number;
     }): Promise<{

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

@@ -1,4 +1,4 @@
-import { type ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
+import { type IBranchHierarchyResolver, 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';
@@ -12,22 +12,23 @@ export interface IFlowRunOptions {
     input: FlowInput;
     startAt?: string;
     request: Record<string, unknown>;
+    authorization?: string;
     exposeDetails: boolean;
-    systemAuthorized: boolean;
 }
 export declare const flowTimeout: (timeoutMs: unknown) => number;
-type RunnableFlow = IFlowSettings & {
-    timeoutMs: 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 branchHierarchy?;
     private readonly logger;
-    constructor(provider: EntityBuilderDataSourceProvider, ruleEngine: RuleEngineService, moduleRef: ModuleRef, permissionCache: SharedPermissionCacheService, config: EntityBuilderConfigService);
-    run(definition: RunnableFlow, options: IFlowRunOptions): Promise<IFlowRunResult>;
+    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;
     private limitStatementTime;
     private commitProgress;
@@ -38,4 +39,3 @@ export declare class FlowExecutorService {
     private createEnv;
     private publishPendingEvents;
 }
-export {};

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

@@ -50,7 +50,7 @@ export declare class GenericEntityService {
     private insertRow;
     private updateRow;
     private assertUpdatable;
-    delete(id: string, user: ILoggedUserInfo | null, options?: IGenericWriteOptions): Promise<void>;
+    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<{

package/services/index.d.ts

@@ -19,9 +19,11 @@ 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-api-key.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';
+export * from './definition-bundle.diff.js';
+export * from './definition-bundle.file.js';
+export * from './definition-bundle.service.js';

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

@@ -30,7 +30,9 @@ export declare class SchemaEvolutionService {
     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>;
+    apply(request: SchemaChangeRequestDto, user: ILoggedUserInfo | null, options?: {
+        fieldId?: string;
+    }): Promise<ISchemaChangeApplied>;
     inspect(entityDefinitionId: string): Promise<ISchemaCheckResult>;
     history(entityDefinitionId: string, limit?: number): Promise<SchemaChangeLog[]>;
     private loadEntity;

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

@@ -11,6 +11,10 @@ export interface ICreatedEntity {
     definition: EntityDefinition;
     warnings: IMessageRef[];
 }
+export interface IPresetIds {
+    entityId?: string;
+    fieldIds?: Record<string, string>;
+}
 export declare class SchemaSyncService {
     private readonly dataSourceProvider;
     private readonly dialectAdapter;
@@ -24,5 +28,5 @@ export declare class SchemaSyncService {
     private createRun;
     private createEndpointFlow;
     planCreateEntity(dto: CreateDynamicEntityDto, user: ILoggedUserInfo | null): Promise<ISchemaChangePlan>;
-    createEntity(dto: CreateDynamicEntityDto, user: ILoggedUserInfo | null): Promise<ICreatedEntity>;
+    createEntity(dto: CreateDynamicEntityDto, user: ILoggedUserInfo | null, ids?: IPresetIds): Promise<ICreatedEntity>;
 }

package/controllers/flow-api-key.controller.d.ts

@@ -1,14 +0,0 @@
-import { type ILoggedUserInfo, SingleResponseDto } from '@flusys/nestjs-shared';
-import { CreateFlowApiKeyDto, FlowIdDto, IdBodyDto } from '../dtos/flow.dto.js';
-import { FlowApiKeyService, type IFlowApiKeyInfo } from '../services/flow-api-key.service.js';
-export declare class FlowApiKeyController {
-    private readonly keys;
-    constructor(keys: FlowApiKeyService);
-    create(dto: CreateFlowApiKeyDto, user: ILoggedUserInfo): Promise<SingleResponseDto<{
-        key: string;
-        info: IFlowApiKeyInfo;
-    }>>;
-    list(dto: FlowIdDto): Promise<SingleResponseDto<IFlowApiKeyInfo[]>>;
-    revoke(dto: IdBodyDto): Promise<SingleResponseDto<null>>;
-    remove(dto: IdBodyDto): Promise<SingleResponseDto<null>>;
-}

package/entities/flow-api-key.entity.d.ts

@@ -1,10 +0,0 @@
-import { Identity } from '@flusys/nestjs-shared';
-export declare class FlowApiKey extends Identity {
-    flowId: string;
-    name: string;
-    keyPrefix: string;
-    keyHash: string;
-    isActive: boolean;
-    expiresAt: Date | null;
-    lastUsedAt: Date | null;
-}

package/services/flow-api-key.service.d.ts

@@ -1,31 +0,0 @@
-import { type ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
-import { EntityBuilderDataSourceProvider } from './entity-builder-datasource.provider.js';
-export type FlowApiKeyStatus = 'active' | 'revoked' | 'expired';
-export type FlowApiKeyCheck = 'valid' | 'invalid' | 'expired';
-export interface IFlowApiKeyInfo {
-    id: string;
-    flowId: string;
-    name: string;
-    keyPrefix: string;
-    isActive: boolean;
-    status: FlowApiKeyStatus;
-    expiresAt: Date | null;
-    lastUsedAt: Date | null;
-    createdAt: Date;
-}
-export declare class FlowApiKeyService {
-    private readonly provider;
-    constructor(provider: EntityBuilderDataSourceProvider);
-    private repo;
-    private assertFlowExists;
-    private findKey;
-    create(flowId: string, name: string, expiresAt: string | undefined, user: ILoggedUserInfo | null): Promise<{
-        key: string;
-        info: IFlowApiKeyInfo;
-    }>;
-    list(flowId: string): Promise<IFlowApiKeyInfo[]>;
-    revoke(id: string): Promise<void>;
-    remove(id: string): Promise<void>;
-    verify(flowId: string, presented: unknown): Promise<FlowApiKeyCheck>;
-    private info;
-}