@flusys/nestjs-entity-builder 9.0.0

package/controllers/flow-definition.controller.d.ts

@@ -0,0 +1,51 @@
+import { type ILoggedUserInfo, SingleResponseDto } from '@flusys/nestjs-shared';
+import { CreateFlowDefinitionDto, FlowDefinitionResponseDto, FlowIdDto, FlowVersionRefDto, PublishFlowDto, TestFlowDto, UpdateFlowDefinitionDto, ValidateFlowDto } from '../dtos/flow.dto.js';
+import { type IFlowDefinition, type IFlowVersion } from '../interfaces/flow-definition.interface.js';
+import { type IFlowValidationResult } from '../flow-engine/flow-graph.validator.js';
+import { FlowDefinitionService } from '../services/flow-definition.service.js';
+import { FlowRuntimeService } from '../services/flow-runtime.service.js';
+declare const FlowDefinitionController_base: abstract new (service: FlowDefinitionService) => {
+    readonly enabledEndpoints: import("@flusys/nestjs-shared").ApiEndpoint[] | "all";
+    service: FlowDefinitionService;
+    isEnabled(endpoint: import("@flusys/nestjs-shared").ApiEndpoint): boolean;
+    insert(addDto: CreateFlowDefinitionDto, user: ILoggedUserInfo | null): Promise<SingleResponseDto<FlowDefinitionResponseDto>>;
+    insertMany(addDto: CreateFlowDefinitionDto[], user: ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared").BulkResponseDto<FlowDefinitionResponseDto>>;
+    getById(id: string, body: import("@flusys/nestjs-shared").GetByIdBodyDto, user: ILoggedUserInfo | null): Promise<SingleResponseDto<FlowDefinitionResponseDto>>;
+    getByIds(body: import("@flusys/nestjs-shared").GetByIdsDto, user: ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared").ListResponseDto<FlowDefinitionResponseDto>>;
+    update(updateDto: UpdateFlowDefinitionDto, user: ILoggedUserInfo | null): Promise<SingleResponseDto<FlowDefinitionResponseDto>>;
+    updateMany(updateDtos: UpdateFlowDefinitionDto[], user: ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared").BulkResponseDto<FlowDefinitionResponseDto>>;
+    bulkUpsert(dtos: (CreateFlowDefinitionDto | UpdateFlowDefinitionDto)[], user: ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared").BulkResponseDto<FlowDefinitionResponseDto>>;
+    getByFilter(filter: Record<string, any>, user: ILoggedUserInfo | null): Promise<SingleResponseDto<FlowDefinitionResponseDto>>;
+    getAll(filterAndPaginationDto: import("@flusys/nestjs-shared").FilterAndPaginationDto, user: ILoggedUserInfo | null, search?: string): Promise<import("@flusys/nestjs-shared").ListResponseDto<FlowDefinitionResponseDto>>;
+    delete(deleteDto: import("@flusys/nestjs-shared").DeleteDto, user: ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared").MessageResponseDto>;
+};
+export declare class FlowDefinitionController extends FlowDefinitionController_base {
+    flowDefinitionService: FlowDefinitionService;
+    private readonly runtime;
+    constructor(flowDefinitionService: FlowDefinitionService, runtime: FlowRuntimeService);
+    validate(dto: ValidateFlowDto): Promise<SingleResponseDto<IFlowValidationResult>>;
+    publish(dto: PublishFlowDto, user: ILoggedUserInfo): Promise<SingleResponseDto<IFlowDefinition>>;
+    versions(dto: FlowIdDto): Promise<SingleResponseDto<IFlowVersion[]>>;
+    version(dto: FlowVersionRefDto): Promise<SingleResponseDto<IFlowVersion>>;
+    restoreVersion(dto: FlowVersionRefDto, user: ILoggedUserInfo): Promise<SingleResponseDto<IFlowDefinition>>;
+    discardDraft(dto: FlowIdDto, user: ILoggedUserInfo): Promise<SingleResponseDto<IFlowDefinition>>;
+    testRun(dto: TestFlowDto, user: ILoggedUserInfo, req: {
+        ip?: string;
+        headers: Record<string, unknown>;
+    }): Promise<{
+        success: boolean;
+        message: string;
+        messageKey: "entity_builder.flow.test.success";
+        data: {
+            warnings: import("@flusys/nestjs-shared").IMessageRef[];
+            status: "success" | "failed" | "rejected";
+            statusCode: number;
+            body: unknown;
+            error?: string;
+            trace: import("../index.js").IFlowTraceEntry[];
+            durationMs: number;
+            savedUpTo?: import("../index.js").IFlowSavePoint;
+        };
+    }>;
+}
+export {};

package/controllers/flow-execution.controller.d.ts

@@ -0,0 +1,21 @@
+import { SingleResponseDto } from '@flusys/nestjs-shared';
+import { IdBodyDto, ListFlowExecutionsDto } from '../dtos/flow.dto.js';
+import { FlowExecutionService } from '../services/flow-execution.service.js';
+export declare class FlowExecutionController {
+    private readonly executions;
+    constructor(executions: FlowExecutionService);
+    list(dto: ListFlowExecutionsDto): Promise<{
+        success: boolean;
+        message: string;
+        messageKey: "entity_builder.flow.executions.success";
+        data: import("../index.js").FlowExecution[];
+        meta: {
+            total: number;
+            page: number;
+            pageSize: number;
+            count: number;
+            hasMore: boolean;
+        };
+    }>;
+    get(dto: IdBodyDto): Promise<SingleResponseDto<unknown>>;
+}

package/controllers/flow-runtime.controller.d.ts

@@ -0,0 +1,24 @@
+import { type FlowDefinition } from '../entities/flow-definition.entity.js';
+import { type IFlowEndpoint } from '../flow-engine/flow.types.js';
+import { FlowRuntimeService } from '../services/flow-runtime.service.js';
+type FlowRequest = {
+    flowDefinition: FlowDefinition;
+    flowEndpoint: IFlowEndpoint;
+    user?: never;
+    ip?: string;
+    headers: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    path?: string;
+};
+export declare class FlowRuntimeController {
+    private readonly runtime;
+    constructor(runtime: FlowRuntimeService);
+    run(_slug: string, body: unknown, req: FlowRequest, res: {
+        status(code: number): unknown;
+    }): Promise<unknown>;
+    runEndpoint(_slug: string, _endpoint: string, body: unknown, req: FlowRequest, res: {
+        status(code: number): unknown;
+    }): Promise<unknown>;
+    private answer;
+}
+export {};

package/controllers/index.d.ts

@@ -0,0 +1,5 @@
+export * from './entity-definition.controller.js';
+export * from './field-definition.controller.js';
+export * from './flow-definition.controller.js';
+export * from './flow-execution.controller.js';
+export * from './flow-runtime.controller.js';

package/docs/entity-builder-swagger.config.d.ts

@@ -0,0 +1,3 @@
+import { type IBootstrapAppConfig } from '@flusys/nestjs-core';
+import { type IModuleSwaggerOptions } from '@flusys/nestjs-core/docs';
+export declare function entityBuilderSwaggerConfig(bootstrapConfig?: IBootstrapAppConfig): IModuleSwaggerOptions;

package/docs/index.d.ts

@@ -0,0 +1 @@
+export { entityBuilderSwaggerConfig } from './entity-builder-swagger.config.js';

package/dtos/entity-definition.dto.d.ts

@@ -0,0 +1,58 @@
+import { IdentityResponseDto } from '@flusys/nestjs-shared/dtos';
+import { type EntityFlowEndpoint } from '../config/entity-builder.constants.js';
+import { EntityStatus } from '../enums/entity-status.enum.js';
+import { CreateFieldDefinitionDto } from './field-definition.dto.js';
+export declare class CreateEntityDefinitionDto {
+    code: string;
+    label: string;
+    description?: string;
+    isSoftDeleteEnabled?: boolean;
+    isAuditEnabled?: boolean;
+    uiConfig?: Record<string, unknown>;
+}
+declare const UpdateEntityDefinitionDto_base: import("@nestjs/common").Type<Partial<CreateEntityDefinitionDto>>;
+export declare class UpdateEntityDefinitionDto extends UpdateEntityDefinitionDto_base {
+    id: string;
+}
+declare const EntityFieldSpecDto_base: import("@nestjs/common").Type<Omit<CreateFieldDefinitionDto, "entityDefinitionId">>;
+export declare class EntityFieldSpecDto extends EntityFieldSpecDto_base {
+}
+export declare class EntityFlowNamesDto {
+    insert?: string;
+    insertMany?: string;
+    getById?: string;
+    getByIds?: string;
+    getAll?: string;
+    getByFilter?: string;
+    update?: string;
+    updateMany?: string;
+    bulkUpsert?: string;
+    delete?: string;
+}
+export declare class EntityFlowInputLabelsDto {
+    id?: string;
+    ids?: string;
+    search?: string;
+}
+export declare class EntityFlowTextsDto {
+    names?: EntityFlowNamesDto;
+    inputLabels?: EntityFlowInputLabelsDto;
+    noMatchMessage?: string;
+}
+export declare class CreateDynamicEntityDto extends CreateEntityDefinitionDto {
+    fields?: EntityFieldSpecDto[];
+    flowEndpoints?: EntityFlowEndpoint[];
+    flowTexts?: EntityFlowTextsDto;
+}
+export declare class EntityDefinitionResponseDto extends IdentityResponseDto {
+    code: string;
+    label: string;
+    description: string | null;
+    tableName: string;
+    status: EntityStatus;
+    schemaVersion: number;
+    isSoftDeleteEnabled: boolean;
+    isAuditEnabled: boolean;
+    uiConfig: Record<string, unknown> | null;
+}
+export {};

package/dtos/field-definition.dto.d.ts

@@ -0,0 +1,42 @@
+import { IdentityResponseDto } from '@flusys/nestjs-shared/dtos';
+import { FieldType } from '../enums/field-type.enum.js';
+export declare class CreateFieldDefinitionDto {
+    entityDefinitionId: string;
+    code: string;
+    label: string;
+    fieldType: FieldType;
+    nullable?: boolean;
+    unique?: boolean;
+    isIndexed?: boolean;
+    defaultValue?: unknown;
+    validationRules?: Record<string, unknown>;
+    selectOptions?: unknown[];
+    relationTargetEntityId?: string;
+    order?: number;
+    uiConfig?: Record<string, unknown>;
+    isSearchable?: boolean;
+}
+declare const UpdateFieldDefinitionDto_base: import("@nestjs/common").Type<Partial<CreateFieldDefinitionDto>>;
+export declare class UpdateFieldDefinitionDto extends UpdateFieldDefinitionDto_base {
+    id: string;
+}
+export declare class FieldDefinitionResponseDto extends IdentityResponseDto {
+    entityDefinitionId: string;
+    code: string;
+    label: string;
+    fieldType: FieldType;
+    dbType: string;
+    nullable: boolean;
+    unique: boolean;
+    isIndexed: boolean;
+    defaultValue: unknown | null;
+    validationRules: Record<string, unknown> | null;
+    selectOptions: unknown[] | null;
+    relationTargetEntityId: string | null;
+    order: number;
+    uiConfig: Record<string, unknown> | null;
+    isSearchable: boolean;
+    isSystemField: boolean;
+    deprecatedAt: Date | null;
+}
+export {};

package/dtos/flow.dto.d.ts

@@ -0,0 +1,76 @@
+import { IdentityResponseDto } from '@flusys/nestjs-shared/dtos';
+import { type IFlowSnapshot } from '../interfaces/flow-definition.interface.js';
+import { type FlowInput, type IFlowEdge, type IFlowNode } from '../flow-engine/flow.types.js';
+export declare class CreateFlowDefinitionDto {
+    name: string;
+    slug: string;
+    description?: string;
+    isActive?: boolean;
+    retainExecutions?: number;
+    nodes: IFlowNode[];
+    edges: IFlowEdge[];
+}
+declare const UpdateFlowDefinitionDto_base: import("@nestjs/common").Type<Partial<CreateFlowDefinitionDto>>;
+export declare class UpdateFlowDefinitionDto extends UpdateFlowDefinitionDto_base {
+    id: string;
+}
+declare const FlowDraftDto_base: import("@nestjs/common").Type<Omit<CreateFlowDefinitionDto, "name">>;
+export declare class FlowDraftDto extends FlowDraftDto_base {
+    name?: string;
+    id?: string;
+    version?: unknown;
+    draft?: unknown;
+    createdAt?: unknown;
+    updatedAt?: unknown;
+    deletedAt?: unknown;
+    createdById?: unknown;
+    updatedById?: unknown;
+    deletedById?: unknown;
+}
+export declare class TestFlowRequestDto {
+    headers?: Record<string, string>;
+    query?: Record<string, string>;
+    ip?: string;
+}
+export declare class TestFlowDto {
+    flowId?: string;
+    definition?: FlowDraftDto;
+    endpoint?: string;
+    input?: FlowInput;
+    mode?: 'dry_run' | 'live';
+    request?: TestFlowRequestDto;
+}
+export declare class ValidateFlowDto {
+    definition: FlowDraftDto;
+}
+export declare class FlowIdDto {
+    flowId: string;
+}
+export declare class PublishFlowDto {
+    id: string;
+    note?: string;
+}
+export declare class FlowVersionRefDto extends FlowIdDto {
+    version: number;
+}
+export declare class IdBodyDto {
+    id: string;
+}
+export declare class ListFlowExecutionsDto {
+    flowId?: string;
+    status?: string;
+    page?: number;
+    pageSize?: number;
+}
+export declare class FlowDefinitionResponseDto extends IdentityResponseDto {
+    name: string;
+    slug: string;
+    description: string | null;
+    isActive: boolean;
+    retainExecutions: number;
+    nodes: IFlowNode[];
+    edges: IFlowEdge[];
+    version: number;
+    draft: IFlowSnapshot | null;
+}
+export {};

package/dtos/index.d.ts

@@ -0,0 +1,3 @@
+export * from './entity-definition.dto.js';
+export * from './field-definition.dto.js';
+export * from './schema-change.dto.js';

package/dtos/schema-change.dto.d.ts

@@ -0,0 +1,53 @@
+import { EntityStatus } from '../enums/entity-status.enum.js';
+import { FieldType } from '../enums/field-type.enum.js';
+import { EntityFieldSpecDto } from './entity-definition.dto.js';
+export declare enum SchemaChangeAction {
+    ADD_FIELD = "add_field",
+    UPDATE_FIELD = "update_field",
+    DEPRECATE_FIELD = "deprecate_field",
+    RESTORE_FIELD = "restore_field",
+    PURGE_FIELD = "purge_field",
+    UPDATE_ENTITY = "update_entity",
+    DROP_ENTITY = "drop_entity",
+    REPAIR = "repair"
+}
+export declare const FIELD_CHANGE_KEYS: readonly ["label", "code", "fieldType", "nullable", "unique", "isIndexed", "defaultValue", "validationRules", "selectOptions", "order", "uiConfig", "isSearchable", "relationTargetEntityId"];
+export declare const ENTITY_CHANGE_KEYS: readonly ["label", "description", "uiConfig", "isSoftDeleteEnabled", "isAuditEnabled", "status"];
+export declare class FieldChangesDto {
+    label?: string;
+    code?: string;
+    fieldType?: FieldType;
+    nullable?: boolean;
+    unique?: boolean;
+    isIndexed?: boolean;
+    isSearchable?: boolean;
+    defaultValue?: unknown;
+    validationRules?: Record<string, unknown> | null;
+    selectOptions?: unknown[] | null;
+    order?: number;
+    uiConfig?: Record<string, unknown> | null;
+    relationTargetEntityId?: string | null;
+}
+export declare class EntityChangesDto {
+    label?: string;
+    description?: string | null;
+    uiConfig?: Record<string, unknown> | null;
+    isSoftDeleteEnabled?: boolean;
+    isAuditEnabled?: boolean;
+    status?: EntityStatus;
+}
+export declare class SchemaChangeRequestDto {
+    action: SchemaChangeAction;
+    entityDefinitionId?: string;
+    fieldDefinitionId?: string;
+    field?: EntityFieldSpecDto;
+    changes?: Record<string, unknown>;
+    backfillValue?: unknown;
+    rewriteReferences?: boolean;
+    confirmCode?: string;
+    confirm?: boolean;
+    expectedUpdatedAt?: string;
+}
+export declare class SchemaCheckRequestDto {
+    entityDefinitionId: string;
+}

package/entities/entity-definition.entity.d.ts

@@ -0,0 +1,15 @@
+import { Identity } from '@flusys/nestjs-shared';
+import type { FieldDefinition } from './field-definition.entity.js';
+import { EntityStatus } from '../enums/entity-status.enum.js';
+export declare class EntityDefinition extends Identity {
+    code: string;
+    label: string;
+    description: string | null;
+    tableName: string;
+    status: EntityStatus;
+    schemaVersion: number;
+    isSoftDeleteEnabled: boolean;
+    isAuditEnabled: boolean;
+    uiConfig: Record<string, unknown> | null;
+    fields?: FieldDefinition[];
+}

package/entities/field-definition.entity.d.ts

@@ -0,0 +1,23 @@
+import { Identity } from '@flusys/nestjs-shared';
+import type { EntityDefinition } from './entity-definition.entity.js';
+import { FieldType } from '../enums/field-type.enum.js';
+export declare class FieldDefinition extends Identity {
+    entityDefinition?: EntityDefinition;
+    entityDefinitionId: string;
+    code: string;
+    label: string;
+    fieldType: FieldType;
+    dbType: string;
+    nullable: boolean;
+    unique: boolean;
+    isIndexed: boolean;
+    defaultValue: unknown | null;
+    validationRules: Record<string, unknown> | null;
+    selectOptions: unknown[] | null;
+    relationTargetEntityId: string | null;
+    order: number;
+    uiConfig: Record<string, unknown> | null;
+    isSearchable: boolean;
+    isSystemField: boolean;
+    deprecatedAt: Date | null;
+}

package/entities/flow-definition.entity.d.ts

@@ -0,0 +1,14 @@
+import { Identity } from '@flusys/nestjs-shared';
+import type { IFlowEdge, IFlowNode } from '../flow-engine/flow.types.js';
+import type { IFlowSnapshot } from '../interfaces/flow-definition.interface.js';
+export declare class FlowDefinition extends Identity {
+    name: string;
+    slug: string;
+    description: string | null;
+    isActive: boolean;
+    retainExecutions: number;
+    nodes: IFlowNode[];
+    edges: IFlowEdge[];
+    version: number;
+    draft: IFlowSnapshot | null;
+}

package/entities/flow-execution.entity.d.ts

@@ -0,0 +1,19 @@
+import { Identity } from '@flusys/nestjs-shared';
+import type { IFlowTraceEntry } from '../flow-engine/flow-run.types.js';
+export declare class FlowExecution extends Identity {
+    flowId: string | null;
+    flowSlug: string;
+    flowVersion: number | null;
+    status: string;
+    trigger: string;
+    mode: string;
+    statusCode: number;
+    input: Record<string, unknown> | null;
+    output: string | null;
+    error: string | null;
+    trace: IFlowTraceEntry[] | null;
+    durationMs: number;
+    startedAt: Date;
+    actorId: string | null;
+    callerIp: string | null;
+}

package/entities/flow-version.entity.d.ts

@@ -0,0 +1,10 @@
+import { Identity } from '@flusys/nestjs-shared';
+import type { IFlowSnapshot } from '../interfaces/flow-definition.interface.js';
+export declare class FlowVersion extends Identity {
+    flowId: string;
+    version: number;
+    definition: IFlowSnapshot;
+    note: string | null;
+    publishedAt: Date | null;
+    publishedById: string | null;
+}

package/entities/index.d.ts

@@ -0,0 +1,14 @@
+export * from './entity-definition.entity.js';
+export * from './field-definition.entity.js';
+export * from './schema-change-log.entity.js';
+export * from './flow-definition.entity.js';
+export * from './flow-execution.entity.js';
+export * from './flow-version.entity.js';
+import { EntityDefinition } from './entity-definition.entity.js';
+import { FieldDefinition } from './field-definition.entity.js';
+import { SchemaChangeLog } from './schema-change-log.entity.js';
+import { FlowDefinition } from './flow-definition.entity.js';
+import { FlowExecution } from './flow-execution.entity.js';
+import { FlowVersion } from './flow-version.entity.js';
+export declare const EntityBuilderEntities: (typeof EntityDefinition | typeof FieldDefinition | typeof SchemaChangeLog | typeof FlowDefinition | typeof FlowExecution | typeof FlowVersion)[];
+export declare function getEntityBuilderEntities(): typeof EntityBuilderEntities;

package/entities/schema-change-log.entity.d.ts

@@ -0,0 +1,15 @@
+import { Identity } from '@flusys/nestjs-shared';
+import { DdlOperation } from '../enums/ddl-operation.enum.js';
+export declare class SchemaChangeLog extends Identity {
+    entityDefinitionId: string | null;
+    entityCode: string | null;
+    operation: DdlOperation;
+    tableName: string;
+    fieldDefinitionId: string | null;
+    diff: Record<string, unknown>;
+    generatedSql: string[];
+    downSql: string[] | null;
+    status: string;
+    errorMessage: string | null;
+    performedById: string | null;
+}

package/enums/ddl-operation.enum.d.ts

@@ -0,0 +1,13 @@
+export declare enum DdlOperation {
+    CREATE_TABLE = "CREATE_TABLE",
+    ADD_COLUMN = "ADD_COLUMN",
+    CREATE_INDEX = "CREATE_INDEX",
+    MARK_DEPRECATED = "MARK_DEPRECATED",
+    RESTORE_FIELD = "RESTORE_FIELD",
+    ALTER_FIELD = "ALTER_FIELD",
+    RENAME_FIELD = "RENAME_FIELD",
+    DROP_COLUMN = "DROP_COLUMN",
+    ALTER_ENTITY = "ALTER_ENTITY",
+    DROP_TABLE = "DROP_TABLE",
+    REPAIR = "REPAIR"
+}

package/enums/entity-status.enum.d.ts

@@ -0,0 +1,5 @@
+export declare enum EntityStatus {
+    DRAFT = "DRAFT",
+    ACTIVE = "ACTIVE",
+    DEPRECATED = "DEPRECATED"
+}

package/enums/field-type.enum.d.ts

@@ -0,0 +1,15 @@
+export declare enum FieldType {
+    TEXT = "TEXT",
+    LONG_TEXT = "LONG_TEXT",
+    INTEGER = "INTEGER",
+    DECIMAL = "DECIMAL",
+    BOOLEAN = "BOOLEAN",
+    DATE = "DATE",
+    DATETIME = "DATETIME",
+    EMAIL = "EMAIL",
+    SINGLE_SELECT = "SINGLE_SELECT",
+    MULTI_SELECT = "MULTI_SELECT",
+    RELATION = "RELATION",
+    JSON = "JSON",
+    FILE = "FILE"
+}

package/enums/index.d.ts

@@ -0,0 +1,3 @@
+export * from './field-type.enum.js';
+export * from './entity-status.enum.js';
+export * from './ddl-operation.enum.js';