@flusys/nestjs-entity-builder 9.0.0

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

@@ -0,0 +1,33 @@
+import { type IIdentity } from '@flusys/nestjs-shared/interfaces';
+import { type EntityStatus } from '../enums/entity-status.enum.js';
+import { type FieldType } from '../enums/field-type.enum.js';
+export interface IEntityDefinition extends IIdentity {
+    code: string;
+    label: string;
+    description: string | null;
+    tableName: string;
+    status: EntityStatus;
+    schemaVersion: number;
+    isSoftDeleteEnabled: boolean;
+    isAuditEnabled: boolean;
+    uiConfig: Record<string, unknown> | null;
+}
+export interface IFieldDefinition extends IIdentity {
+    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/interfaces/flow-definition.interface.d.ts

@@ -0,0 +1,24 @@
+import { type IIdentity } from '@flusys/nestjs-shared/interfaces';
+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;
+    retainExecutions: number;
+    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 | null;
+    publishedById: string | null;
+    definition?: IFlowSnapshot;
+}

package/interfaces/generic-record.interface.d.ts

@@ -0,0 +1,15 @@
+import { type ObjectLiteral } from 'typeorm';
+export interface IGenericRecord extends ObjectLiteral {
+    id: string;
+    [key: string]: unknown;
+}
+export declare const RECORD_FILTER_OPS: readonly ["eq", "ne", "gt", "gte", "lt", "lte", "in", "is_null", "not_null"];
+export type RecordFilterOp = (typeof RECORD_FILTER_OPS)[number];
+export interface IRecordFilterCondition {
+    op: RecordFilterOp;
+    value?: unknown;
+}
+export declare const RECORD_FILTER_LIMITS: {
+    readonly MAX_IN_VALUES: 100;
+};
+export declare function isRecordFilterCondition(value: unknown): value is IRecordFilterCondition;

package/interfaces/index.d.ts

@@ -0,0 +1,5 @@
+export * from './field-definition.interface.js';
+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';

package/interfaces/reference-provider.interface.d.ts

@@ -0,0 +1,8 @@
+import { type EntityManager } from 'typeorm';
+import { type ISchemaImpact } from '../services/schema-change.types.js';
+export interface IEntityReferenceProvider {
+    findEntityReferences(entityCode: string): Promise<ISchemaImpact[]>;
+    findFieldReferences(entityCode: string, fieldCode: string): Promise<ISchemaImpact[]>;
+    rewriteFieldReferences(entityCode: string, from: string, to: string, manager?: EntityManager): Promise<number>;
+}
+export declare const FLOW_REFERENCE_PROVIDER = "FLOW_REFERENCE_PROVIDER";

package/interfaces/schema-dialect-adapter.interface.d.ts

@@ -0,0 +1,15 @@
+import { type ColumnType, type QueryRunner } from 'typeorm';
+import { type FieldType } from '../enums/field-type.enum.js';
+export type SupportedDbDriver = 'postgres' | 'mysql';
+export interface IColumnSizing {
+    length?: string;
+    precision?: number;
+    scale?: number;
+}
+export interface ISchemaDialectAdapter {
+    mapFieldType(fieldType: FieldType, driver: SupportedDbDriver): ColumnType;
+    getColumnSizing(fieldType: FieldType, driver?: SupportedDbDriver): IColumnSizing;
+    maxIdentifierLength(driver: SupportedDbDriver): number;
+    acquireEntityLock(queryRunner: QueryRunner, lockKey: string, driver: SupportedDbDriver): Promise<void>;
+    releaseEntityLock(queryRunner: QueryRunner, lockKey: string, driver: SupportedDbDriver): Promise<void>;
+}

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

@@ -0,0 +1,10 @@
+import { type DynamicModule } from '@nestjs/common';
+import { type EntityBuilderModuleAsyncOptions, type EntityBuilderModuleOptions } from '../interfaces/entity-builder-module.interface.js';
+export declare class EntityBuilderModule {
+    private static readonly CONTROLLERS;
+    private static readonly EXPORTS;
+    static forRoot(options: EntityBuilderModuleOptions): DynamicModule;
+    static forRootAsync(options: EntityBuilderModuleAsyncOptions): DynamicModule;
+    private static buildProviders;
+    private static buildAsyncProviders;
+}

package/modules/index.d.ts

@@ -0,0 +1 @@
+export * from './entity-builder.module.js';

package/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "@flusys/nestjs-entity-builder",
+  "version": "9.0.0",
+  "description": "Dynamic entity builder module - runtime entity/field metadata, driven DDL, and generic CRUD",
+  "type": "module",
+  "main": "./fesm/index.js",
+  "module": "./fesm/index.js",
+  "types": "./index.d.ts",
+  "sideEffects": false,
+  "keywords": [
+    "nestjs",
+    "@flusys",
+    "entity-builder",
+    "dynamic-entities",
+    "ddl",
+    "schema",
+    "backendless"
+  ],
+  "license": "UNLICENSED",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./fesm/index.js"
+    },
+    "./config": {
+      "types": "./config/index.d.ts",
+      "import": "./fesm/config/index.js"
+    },
+    "./controllers": {
+      "types": "./controllers/index.d.ts",
+      "import": "./fesm/controllers/index.js"
+    },
+    "./docs": {
+      "types": "./docs/index.d.ts",
+      "import": "./fesm/docs/index.js"
+    },
+    "./dtos": {
+      "types": "./dtos/index.d.ts",
+      "import": "./fesm/dtos/index.js"
+    },
+    "./entities": {
+      "types": "./entities/index.d.ts",
+      "import": "./fesm/entities/index.js"
+    },
+    "./enums": {
+      "types": "./enums/index.d.ts",
+      "import": "./fesm/enums/index.js"
+    },
+    "./guards": {
+      "types": "./guards/index.d.ts",
+      "import": "./fesm/guards/index.js"
+    },
+    "./interfaces": {
+      "types": "./interfaces/index.d.ts",
+      "import": "./fesm/interfaces/index.js"
+    },
+    "./modules": {
+      "types": "./modules/index.d.ts",
+      "import": "./fesm/modules/index.js"
+    },
+    "./rule-engine": {
+      "types": "./rule-engine/index.d.ts",
+      "import": "./fesm/rule-engine/index.js"
+    },
+    "./services": {
+      "types": "./services/index.d.ts",
+      "import": "./fesm/services/index.js"
+    },
+    "./*": {
+      "types": "./*.d.ts",
+      "import": "./fesm/*.js"
+    }
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^12.0.0",
+    "@nestjs/config": "^12.0.0",
+    "@nestjs/core": "^12.0.0",
+    "@nestjs/platform-express": "^12.0.0",
+    "@nestjs/swagger": "^12.0.0",
+    "@nestjs/typeorm": "^12.0.0",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.15.0",
+    "typeorm": "^0.3.0",
+    "express": "^5.0.0",
+    "rxjs": "^7.8.0"
+  },
+  "dependencies": {
+    "@flusys/nestjs-core": "9.0.0",
+    "@flusys/nestjs-shared": "9.0.0",
+    "re2js": "^2.8.6",
+    "quickjs-emscripten": "^0.32.0"
+  }
+}

package/rule-engine/index.d.ts

@@ -0,0 +1,3 @@
+export * from './rule.interface.js';
+export * from './rule-evaluation-context.interface.js';
+export * from './rule-engine.service.js';

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

@@ -0,0 +1,40 @@
+import { type IPermissionResolver } from '@flusys/nestjs-shared/interfaces';
+import { SharedPermissionCacheService } from '@flusys/nestjs-shared/modules';
+import { type IRulePermissionResolver, type RuleEvaluationContext } from './rule-evaluation-context.interface.js';
+import { type RuleCondition, type RuleExpression, type RuleGroup } from './rule.interface.js';
+interface IEvaluationBudget {
+    lookups?: number;
+    permissions?: IRulePermissionResolver;
+}
+export declare class RuleEngineService {
+    private readonly permissionResolver?;
+    private readonly permissionCache?;
+    constructor(permissionResolver?: IPermissionResolver | undefined, permissionCache?: SharedPermissionCacheService | undefined);
+    createPermissionResolver(user: RuleEvaluationContext['user']): IRulePermissionResolver;
+    evaluateGroup(group: RuleGroup, ctx: RuleEvaluationContext, depth?: number, budget?: IEvaluationBudget): Promise<boolean>;
+    private every;
+    evaluateCondition(condition: RuleCondition, ctx: RuleEvaluationContext, budget?: IEvaluationBudget): Promise<boolean>;
+    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;
+    private getPath;
+    private resolveFunction;
+    private hasPermissions;
+    private toText;
+    private toTime;
+    private toDurationUnit;
+    private toUtcOffset;
+    private ordered;
+    private toContainerCheck;
+    private isEmptyValue;
+    private hasIntersection;
+    private toNumber;
+    private tryToNumber;
+    private applyArithmetic;
+    private assertWithinLimits;
+}
+export {};

package/rule-engine/rule-evaluation-context.interface.d.ts

@@ -0,0 +1,28 @@
+import { type ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
+export interface IRuleLookupQuery {
+    filter: Record<string, unknown>;
+    sort?: Record<string, 'ASC' | 'DESC'>;
+    limit: number;
+}
+export interface IRuleLookupResolver {
+    find(entityCode: string, query: IRuleLookupQuery): Promise<{
+        rows: Record<string, unknown>[];
+        total: number;
+    }>;
+}
+export interface IRulePermissionResolver {
+    granted(branchId: string | null | undefined): Promise<string[]>;
+}
+export interface RuleEvaluationContext {
+    input?: Record<string, unknown> | unknown[];
+    context?: Record<string, Record<string, unknown>>;
+    vars?: Record<string, unknown>;
+    loop?: {
+        item: unknown;
+        index: number;
+    };
+    request?: Record<string, unknown>;
+    user: ILoggedUserInfo | null;
+    lookupResolver?: IRuleLookupResolver;
+    permissions?: IRulePermissionResolver;
+}

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

@@ -0,0 +1,3 @@
+export declare function parseIpRanges(value: unknown): string[];
+export declare function invalidIpRange(value: unknown): string | null;
+export declare function ipInRanges(ip: unknown, ranges: unknown): boolean;

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

@@ -0,0 +1,10 @@
+import { type ILoggedUserInfo, type IPermissionResolver } from '@flusys/nestjs-shared/interfaces';
+import { type SharedPermissionCacheService } from '@flusys/nestjs-shared/modules';
+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 parsePermissionCodes(value: unknown): string[];
+export declare function toBranchArgument(args: unknown[], index: number): string | null | undefined;

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

@@ -0,0 +1,4 @@
+export type RulePatternProblem = 'too_long' | 'invalid' | 'too_complex';
+export declare function rulePatternProblem(pattern: string): RulePatternProblem | null;
+export declare function matchesPattern(input: unknown, pattern: unknown): boolean;
+export declare function extractPattern(input: unknown, pattern: unknown, group?: unknown): string | null;

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

@@ -0,0 +1,5 @@
+export declare const ISO_DATE_PREFIX: RegExp;
+export declare function parseDateText(text: string): number;
+export declare function valuesEqual(a: unknown, b: unknown): boolean;
+export declare const includesValue: (list: readonly unknown[], value: unknown) => boolean;
+export declare const equalsOperand: (value: unknown) => unknown;

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

@@ -0,0 +1,79 @@
+import { type RecordFilterOp } from '../interfaces/generic-record.interface.js';
+export type RuleLogicOperator = 'AND' | 'OR' | 'NOT';
+export declare const RULE_COMPARISON_OPERATORS: readonly ["equals", "not_equals", "greater_than", "less_than", "greater_or_equal", "less_or_equal", "contains", "not_contains", "starts_with", "ends_with", "is_empty", "is_not_empty", "in", "not_in", "is_any_of", "is_none_of", "is_true", "is_false", "matches", "not_matches"];
+export type RuleComparisonOperator = (typeof RULE_COMPARISON_OPERATORS)[number];
+export interface RuleCondition {
+    field?: string;
+    left?: RuleExpression;
+    comparison: RuleComparisonOperator;
+    value?: unknown | {
+        $field: string;
+    } | {
+        $expr: RuleExpression;
+    };
+}
+export interface RuleGroup {
+    operator: RuleLogicOperator;
+    conditions: Array<RuleCondition | RuleGroup>;
+}
+export declare function isRuleGroup(node: RuleCondition | RuleGroup): node is RuleGroup;
+export type RuleArithmeticOp = 'sum' | 'subtract' | 'multiply' | 'divide' | 'min' | 'max';
+export declare const RULE_PERMISSION_FUNCTIONS: readonly ["HAS_PERMISSION", "HAS_ANY_PERMISSION", "HAS_ALL_PERMISSIONS"];
+export type RulePermissionFunctionName = (typeof RULE_PERMISSION_FUNCTIONS)[number];
+export declare const RULE_REQUEST_FUNCTIONS: readonly ["HEADER", "QUERY_PARAM", "IP_IN_RANGE"];
+export type RuleRequestFunctionName = (typeof RULE_REQUEST_FUNCTIONS)[number];
+export type RuleTextFunctionName = 'LOWER' | 'UPPER' | 'TRIM' | 'LENGTH' | 'SPLIT_PART' | 'REGEX_EXTRACT' | 'REPLACE' | 'TO_NUMBER';
+export type RuleFunctionName = 'NOW' | 'UUID' | 'CURRENT_USER_ID' | 'COALESCE' | 'ROUND' | 'DATE_DIFF' | 'START_OF_DAY' | 'END_OF_DAY' | 'ADD_DURATION' | RulePermissionFunctionName | RuleRequestFunctionName | RuleTextFunctionName;
+export declare function isPermissionFunction(name: unknown): name is RulePermissionFunctionName;
+export declare const RULE_DURATION_UNITS: readonly ["second", "minute", "hour", "day"];
+export type RuleDurationUnit = (typeof RULE_DURATION_UNITS)[number];
+export type RuleLookupMode = 'exists' | 'count' | 'first';
+export interface RuleLookupFilterCondition {
+    op: RecordFilterOp;
+    value?: RuleExpression;
+}
+export interface RuleLookupExpression {
+    type: 'lookup';
+    entity: string;
+    filter: Record<string, RuleExpression | RuleLookupFilterCondition>;
+    mode: RuleLookupMode;
+    field?: string;
+    sort?: {
+        field: string;
+        direction: 'ASC' | 'DESC';
+    };
+}
+export type RuleExpression = {
+    type: 'literal';
+    value: string | number | boolean | null;
+} | {
+    type: 'field_ref';
+    ref: string;
+} | {
+    type: 'arithmetic';
+    op: RuleArithmeticOp;
+    operands: RuleExpression[];
+} | {
+    type: 'concat';
+    parts: RuleExpression[];
+} | {
+    type: 'function';
+    name: RuleFunctionName;
+    args: RuleExpression[];
+} | {
+    type: 'template';
+    template: string;
+} | RuleLookupExpression;
+export declare const RULE_TEMPLATE_MAX_LENGTH = 4000;
+export declare const RULE_ENGINE_LIMITS: {
+    readonly MAX_GROUP_DEPTH: 8;
+    readonly MAX_CONDITIONS_PER_GROUP: 100;
+    readonly MAX_LOOKUPS: 10;
+    readonly MAX_REGEX_PATTERN_LENGTH: 500;
+    readonly MAX_REGEX_INPUT_LENGTH: 10000;
+    readonly MAX_REGEX_REPEAT: 100;
+    readonly MAX_REGEX_REPEAT_EXPANSION: 300;
+    readonly MAX_UTC_OFFSET_MINUTES: 840;
+    readonly MAX_PERMISSION_CODES: 50;
+    readonly MAX_IP_RANGES: 100;
+};

package/services/database-error.mapper.d.ts

@@ -0,0 +1,2 @@
+export declare function mapDatabaseError(error: unknown, knownFields?: string[]): unknown;
+export declare function mapSchemaError(error: unknown): unknown;

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

@@ -0,0 +1,8 @@
+import { HybridCache } from '@flusys/nestjs-shared/classes';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+export declare class DefinitionCacheService {
+    private readonly cacheManager;
+    private readonly utilsService;
+    constructor(cacheManager: HybridCache, utilsService: UtilsService);
+    clearAll(tenantId?: string): Promise<void>;
+}

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

@@ -0,0 +1,12 @@
+import { type DatabaseMode, type ITenantDatabaseConfig } from '@flusys/nestjs-core';
+import { type IModuleConfigService } from '@flusys/nestjs-shared/interfaces';
+import { type EntityBuilderModuleOptions } from '../interfaces/entity-builder-module.interface.js';
+export declare class EntityBuilderConfigService implements IModuleConfigService {
+    private readonly options;
+    constructor(options: EntityBuilderModuleOptions);
+    isCompanyFeatureEnabled(tenant?: ITenantDatabaseConfig): boolean;
+    getDatabaseMode(): DatabaseMode;
+    isMultiTenant(): boolean;
+    getOptions(): EntityBuilderModuleOptions;
+    getConfig(): import("../index.js").IEntityBuilderConfig | undefined;
+}

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

@@ -0,0 +1,24 @@
+import { MultiTenantDataSourceService } from '@flusys/nestjs-shared/modules';
+import { type IDatabaseConfig, type ITenantDatabaseConfig } from '@flusys/nestjs-core';
+import { type Request } from 'express';
+import { DataSource, type EntitySchema, type ObjectLiteral, type QueryRunner, type Repository } from 'typeorm';
+import { type SupportedDbDriver } from '../interfaces/schema-dialect-adapter.interface.js';
+import { EntityBuilderConfigService } from './entity-builder-config.service.js';
+export declare class EntityBuilderDataSourceProvider extends MultiTenantDataSourceService {
+    protected static readonly tenantConnections: Map<string, DataSource>;
+    protected static singleDataSource: DataSource | null;
+    protected static readonly tenantsRegistry: Map<string, ITenantDatabaseConfig>;
+    protected static initialized: boolean;
+    protected static readonly connectionLocks: Map<string, Promise<DataSource>>;
+    protected static singleConnectionLock: Promise<DataSource> | null;
+    private static readonly registeredSchemas;
+    private static readonly rebuildLocks;
+    constructor(configService: EntityBuilderConfigService, request?: Request);
+    private static buildParentOptions;
+    private get statics();
+    protected createDataSourceFromConfig(config: IDatabaseConfig): Promise<DataSource>;
+    getDriver(): Promise<SupportedDbDriver>;
+    registerDynamicSchema(schema: EntitySchema): Promise<void>;
+    getDynamicRepository<T extends ObjectLiteral>(schema: EntitySchema<T>): Promise<Repository<T>>;
+    getQueryRunner(): Promise<QueryRunner>;
+}

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

@@ -0,0 +1,17 @@
+import { ApiService, HybridCache } from '@flusys/nestjs-shared/classes';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { type ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
+import { type SelectQueryBuilder } from 'typeorm';
+import { type UpdateEntityDefinitionDto, type CreateEntityDefinitionDto } from '../dtos/entity-definition.dto.js';
+import { EntityDefinition } from '../entities/entity-definition.entity.js';
+import { type IEntityDefinition } from '../interfaces/field-definition.interface.js';
+import { EntityBuilderDataSourceProvider } from './entity-builder-datasource.provider.js';
+export declare class EntityDefinitionService extends ApiService<CreateEntityDefinitionDto, UpdateEntityDefinitionDto, IEntityDefinition, EntityDefinition> {
+    protected cacheManager: HybridCache;
+    protected utilsService: UtilsService;
+    constructor(cacheManager: HybridCache, utilsService: UtilsService, dataSourceProvider: EntityBuilderDataSourceProvider);
+    protected getSelectQuery(query: SelectQueryBuilder<EntityDefinition>, user: ILoggedUserInfo | null, select?: string[]): Promise<{
+        query: SelectQueryBuilder<EntityDefinition>;
+        isRaw: boolean;
+    }>;
+}

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

@@ -0,0 +1,27 @@
+import { type EntityFlowEndpoint } from '../config/entity-builder.constants.js';
+import { FieldType } from '../enums/field-type.enum.js';
+import { type CreateFlowDefinitionDto } from '../dtos/flow.dto.js';
+export interface IEntityFlowField {
+    code: string;
+    label?: string;
+    fieldType: FieldType;
+    nullable?: boolean;
+    defaultValue?: unknown;
+    selectOptions?: unknown[] | null;
+    validationRules?: Record<string, unknown> | null;
+}
+export interface IEntityFlowSource {
+    code: string;
+    label: string;
+    fields: IEntityFlowField[];
+}
+type FlowInputLabel = 'id' | 'ids' | 'search';
+export interface IEntityFlowTexts {
+    names?: Partial<Record<EntityFlowEndpoint, string>>;
+    inputLabels?: Partial<Record<FlowInputLabel, string>>;
+    noMatchMessage?: string;
+}
+export declare const ENTITY_FLOW_PATHS: Record<EntityFlowEndpoint, string>;
+export declare const entityFlowSlug: (entityCode: string) => string;
+export declare function buildEntityFlow(entity: IEntityFlowSource, endpoints: readonly EntityFlowEndpoint[], texts?: IEntityFlowTexts): CreateFlowDefinitionDto;
+export {};

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

@@ -0,0 +1,8 @@
+import { type IPermissionActionRegistry } from '@flusys/nestjs-shared';
+import { EntityDefinition } from '../entities/entity-definition.entity.js';
+export declare class EntityPermissionService {
+    private readonly actionRegistry?;
+    constructor(actionRegistry?: IPermissionActionRegistry | undefined);
+    provisionForEntity(definition: EntityDefinition): Promise<void>;
+    deprovisionForEntity(definition: Pick<EntityDefinition, 'code'>): Promise<void>;
+}

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

@@ -0,0 +1,17 @@
+import { ApiService, HybridCache } from '@flusys/nestjs-shared/classes';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { type ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
+import { type SelectQueryBuilder } from 'typeorm';
+import { type UpdateFieldDefinitionDto, type CreateFieldDefinitionDto } from '../dtos/field-definition.dto.js';
+import { FieldDefinition } from '../entities/field-definition.entity.js';
+import { type IFieldDefinition } from '../interfaces/field-definition.interface.js';
+import { EntityBuilderDataSourceProvider } from './entity-builder-datasource.provider.js';
+export declare class FieldDefinitionService extends ApiService<CreateFieldDefinitionDto, UpdateFieldDefinitionDto, IFieldDefinition, FieldDefinition> {
+    protected cacheManager: HybridCache;
+    protected utilsService: UtilsService;
+    constructor(cacheManager: HybridCache, utilsService: UtilsService, dataSourceProvider: EntityBuilderDataSourceProvider);
+    protected getSelectQuery(query: SelectQueryBuilder<FieldDefinition>, user: ILoggedUserInfo | null, select?: string[]): Promise<{
+        query: SelectQueryBuilder<FieldDefinition>;
+        isRaw: boolean;
+    }>;
+}

package/services/field-type-conversion.d.ts

@@ -0,0 +1,15 @@
+import { type IMessageRef } from '@flusys/nestjs-shared/interfaces';
+import { FieldType } from '../enums/field-type.enum.js';
+import { type SupportedDbDriver } from '../interfaces/schema-dialect-adapter.interface.js';
+export interface ITypeConversion {
+    supported: boolean;
+    reason?: IMessageRef;
+    noDbChange?: boolean;
+    using?: (column: string) => string;
+    prechecks: Array<{
+        description: IMessageRef;
+        badRowsWhere: (column: string, driver: SupportedDbDriver) => string;
+    }>;
+    lossy?: IMessageRef;
+}
+export declare function planTypeConversion(from: FieldType, to: FieldType, driver: SupportedDbDriver): ITypeConversion;

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

@@ -0,0 +1,17 @@
+import { type IValidationError } from '@flusys/nestjs-shared/exceptions';
+import { type IMessageRef } from '@flusys/nestjs-shared/interfaces';
+import { FieldType } from '../enums/field-type.enum.js';
+export type IFieldError = IValidationError & IMessageRef;
+export interface IValidatableField {
+    code: string;
+    label: string;
+    fieldType: FieldType;
+    nullable: boolean;
+    defaultValue: unknown;
+    selectOptions: unknown[] | null;
+    validationRules: Record<string, unknown> | null;
+}
+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

@@ -0,0 +1,62 @@
+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 ICompanyAccessResolver, type IEmailAdapter, 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 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 flowNotFound: () => NotFoundException;
+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;
+};
+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?;
+    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, endpoint: IFlowEndpoint | undefined, user: ILoggedUserInfo | null, run: {
+        mode: 'dry_run' | 'live';
+        draft: boolean;
+        saved: boolean;
+    }): Promise<void>;
+    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>;
+    private provisionPermissions;
+}
+export {};