@loopstack/common 0.14.0 → 0.15.1

package/dist/constants/index.d.ts

@@ -1,2 +1 @@
 export * from './auth.constants';
-export * from './module.constants';

package/dist/constants/index.js

@@ -15,4 +15,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./auth.constants"), exports);
-__exportStar(require("./module.constants"), exports);

package/dist/decorators/block.decorator.d.ts

@@ -1,16 +1,18 @@
 import { BlockOptions } from '../interfaces';
-export declare const BLOCK_METADATA_KEY = "block:metadata";
-export declare function BlockConfig(options: BlockOptions): ClassDecorator;
+import { z } from 'zod';
+export declare const BLOCK_METADATA_KEY: unique symbol;
 export declare const INPUT_METADATA_KEY: unique symbol;
 export declare const OUTPUT_METADATA_KEY: unique symbol;
-/**
- * Marks a property as an input parameter
- * Inputs can be read and written
- */
-export declare function Input(): (target: any, propertyKey: string) => void;
-/**
- * Marks a property/getter as an output value
- * Outputs are typically read-only (often getters)
- */
-export declare function Output(): (target: any, propertyKey: string) => void;
-export declare function getDecoratedProperties(metatype: any, metadataKey: symbol): string[];
+export declare const TOOL_METADATA_KEY: unique symbol;
+export declare const DOCUMENT_METADATA_KEY: unique symbol;
+export declare const WORKFLOW_METADATA_KEY: unique symbol;
+export declare const TEMPLATE_HELPER_METADATA_KEY: unique symbol;
+export declare function WithArguments<T extends z.ZodType>(schema: T): ClassDecorator;
+export declare function WithState<T extends z.ZodType>(schema: T): ClassDecorator;
+export declare function BlockConfig(options: BlockOptions): ClassDecorator;
+export declare function Tool(token?: any): PropertyDecorator & MethodDecorator;
+export declare function Document(token?: any): PropertyDecorator & MethodDecorator;
+export declare function Workflow(token?: any): PropertyDecorator & MethodDecorator;
+export declare function Helper(): MethodDecorator;
+export declare function Input(): PropertyDecorator;
+export declare function Output(): PropertyDecorator;

package/dist/decorators/block.decorator.js

@@ -1,55 +1,119 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OUTPUT_METADATA_KEY = exports.INPUT_METADATA_KEY = exports.BLOCK_METADATA_KEY = void 0;
+exports.TEMPLATE_HELPER_METADATA_KEY = exports.WORKFLOW_METADATA_KEY = exports.DOCUMENT_METADATA_KEY = exports.TOOL_METADATA_KEY = exports.OUTPUT_METADATA_KEY = exports.INPUT_METADATA_KEY = exports.BLOCK_METADATA_KEY = void 0;
+exports.WithArguments = WithArguments;
+exports.WithState = WithState;
 exports.BlockConfig = BlockConfig;
+exports.Tool = Tool;
+exports.Document = Document;
+exports.Workflow = Workflow;
+exports.Helper = Helper;
 exports.Input = Input;
 exports.Output = Output;
-exports.getDecoratedProperties = getDecoratedProperties;
 const common_1 = require("@nestjs/common");
-exports.BLOCK_METADATA_KEY = 'block:metadata';
+const block_config_builder_1 = require("../utils/block-config.builder");
+const zod_1 = require("zod");
+exports.BLOCK_METADATA_KEY = Symbol('block');
+exports.INPUT_METADATA_KEY = Symbol('input');
+exports.OUTPUT_METADATA_KEY = Symbol('output');
+exports.TOOL_METADATA_KEY = Symbol('tool');
+exports.DOCUMENT_METADATA_KEY = Symbol('document');
+exports.WORKFLOW_METADATA_KEY = Symbol('workflow');
+exports.TEMPLATE_HELPER_METADATA_KEY = Symbol('templateHelper');
+function WithArguments(schema) {
+    return (target) => {
+        target.argsSchema = schema;
+    };
+}
+function validateStateSchema(schema) {
+    const forbiddenKeys = ['args', 'metadata'];
+    if (schema instanceof zod_1.z.ZodObject) {
+        const shape = schema.shape;
+        const keys = Object.keys(shape);
+        for (const key of forbiddenKeys) {
+            if (keys.includes(key)) {
+                throw new Error(`State schema cannot contain '${key}' key`);
+            }
+        }
+    }
+}
+function WithState(schema) {
+    return (target) => {
+        validateStateSchema(schema);
+        target.stateSchema = schema;
+    };
+}
+function getTools(target) {
+    const keys = Reflect.getMetadata(exports.TOOL_METADATA_KEY, target.prototype) || [];
+    return keys.map(key => String(key));
+}
+function getDocuments(target) {
+    const keys = Reflect.getMetadata(exports.DOCUMENT_METADATA_KEY, target.prototype) || [];
+    return keys.map(key => String(key));
+}
+function getWorkflows(target) {
+    const keys = Reflect.getMetadata(exports.WORKFLOW_METADATA_KEY, target.prototype) || [];
+    return keys.map(key => String(key));
+}
+function getHelpers(target) {
+    const keys = Reflect.getMetadata(exports.TEMPLATE_HELPER_METADATA_KEY, target.prototype) || [];
+    return keys.map(key => String(key));
+}
 function BlockConfig(options) {
     return (target) => {
-        const scope = options.scope ?? common_1.Scope.TRANSIENT;
-        (0, common_1.Injectable)({ scope })(target);
+        target.blockConfig = (0, block_config_builder_1.buildConfig)(options);
+        target.blockTools = getTools(target);
+        target.blockDocuments = getDocuments(target);
+        target.blockWorkflows = getWorkflows(target);
+        target.blockHelpers = getHelpers(target);
         Reflect.defineMetadata(exports.BLOCK_METADATA_KEY, options, target);
-        return target;
     };
 }
-exports.INPUT_METADATA_KEY = Symbol('input');
-exports.OUTPUT_METADATA_KEY = Symbol('output');
-/**
- * Marks a property as an input parameter
- * Inputs can be read and written
- */
+function Tool(token) {
+    return (target, propertyKey) => {
+        const type = token ?? Reflect.getMetadata('design:type', target, propertyKey);
+        if (type) {
+            (0, common_1.Inject)(type)(target, propertyKey);
+        }
+        const existingTools = Reflect.getMetadata(exports.TOOL_METADATA_KEY, target) || [];
+        Reflect.defineMetadata(exports.TOOL_METADATA_KEY, [...existingTools, propertyKey], target);
+    };
+}
+function Document(token) {
+    return (target, propertyKey) => {
+        const type = token ?? Reflect.getMetadata('design:type', target, propertyKey);
+        if (type) {
+            (0, common_1.Inject)(type)(target, propertyKey);
+        }
+        const existingTools = Reflect.getMetadata(exports.DOCUMENT_METADATA_KEY, target) || [];
+        Reflect.defineMetadata(exports.DOCUMENT_METADATA_KEY, [...existingTools, propertyKey], target);
+    };
+}
+function Workflow(token) {
+    return (target, propertyKey) => {
+        const type = token ?? Reflect.getMetadata('design:type', target, propertyKey);
+        if (type) {
+            (0, common_1.Inject)(type)(target, propertyKey);
+        }
+        const existingWorkflows = Reflect.getMetadata(exports.WORKFLOW_METADATA_KEY, target) || [];
+        Reflect.defineMetadata(exports.WORKFLOW_METADATA_KEY, [...existingWorkflows, propertyKey], target);
+    };
+}
+function Helper() {
+    return (target, propertyKey) => {
+        const existing = Reflect.getMetadata(exports.TEMPLATE_HELPER_METADATA_KEY, target) || [];
+        Reflect.defineMetadata(exports.TEMPLATE_HELPER_METADATA_KEY, [...existing, propertyKey], target);
+    };
+}
 function Input() {
-    return function (target, propertyKey) {
-        const constructor = target.constructor;
-        const existingInputs = Reflect.getOwnMetadata(exports.INPUT_METADATA_KEY, constructor) || [];
-        const newInputs = [...existingInputs, propertyKey];
-        Reflect.defineMetadata(exports.INPUT_METADATA_KEY, newInputs, constructor);
+    return (target, propertyKey) => {
+        const existingInputs = Reflect.getMetadata(exports.INPUT_METADATA_KEY, target) || [];
+        Reflect.defineMetadata(exports.INPUT_METADATA_KEY, [...existingInputs, propertyKey], target);
     };
 }
-/**
- * Marks a property/getter as an output value
- * Outputs are typically read-only (often getters)
- */
 function Output() {
-    return function (target, propertyKey) {
-        const constructor = target.constructor;
-        const existingOutputs = Reflect.getOwnMetadata(exports.OUTPUT_METADATA_KEY, constructor) || [];
-        const newOutputs = [...existingOutputs, propertyKey];
-        Reflect.defineMetadata(exports.OUTPUT_METADATA_KEY, newOutputs, constructor);
-    };
-}
-function getDecoratedProperties(metatype, metadataKey) {
-    const properties = new Set();
-    let current = metatype;
-    while (current && current !== Object && current !== Function.prototype) {
-        const metadata = Reflect.getOwnMetadata(metadataKey, current);
-        if (metadata && Array.isArray(metadata)) {
-            metadata.forEach(prop => properties.add(prop));
-        }
-        current = Object.getPrototypeOf(current);
-    }
-    return Array.from(properties);
+    return (target, propertyKey) => {
+        const existingOutputs = Reflect.getMetadata(exports.OUTPUT_METADATA_KEY, target) || [];
+        Reflect.defineMetadata(exports.OUTPUT_METADATA_KEY, [...existingOutputs, propertyKey], target);
+    };
 }

package/dist/decorators/capability-decorator.d.ts

@@ -1,5 +1,2 @@
-import { Type } from '@nestjs/common';
-export declare const CAPABILITY_METADATA = "is_capability";
-export declare const MODULE_FACTORY_CLASS = "module_factory_class";
-export declare function Capability(): (target: any) => void;
-export declare function ModuleFactory(factoryClass: Type<any>): (target: any) => void;
+export declare const FACTORY_MODULE = "FACTORY_MODULE";
+export declare function CapabilityFactory(moduleClass: string): (target: any) => any;

package/dist/decorators/capability-decorator.js

@@ -1,19 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MODULE_FACTORY_CLASS = exports.CAPABILITY_METADATA = void 0;
-exports.Capability = Capability;
-exports.ModuleFactory = ModuleFactory;
+exports.FACTORY_MODULE = void 0;
+exports.CapabilityFactory = CapabilityFactory;
 const common_1 = require("@nestjs/common");
-exports.CAPABILITY_METADATA = 'is_capability';
-exports.MODULE_FACTORY_CLASS = 'module_factory_class';
-function Capability() {
+exports.FACTORY_MODULE = 'FACTORY_MODULE';
+function CapabilityFactory(moduleClass) {
     return (target) => {
         (0, common_1.Injectable)()(target);
-        Reflect.defineMetadata(exports.CAPABILITY_METADATA, true, target);
-    };
-}
-function ModuleFactory(factoryClass) {
-    return (target) => {
-        Reflect.defineMetadata(exports.MODULE_FACTORY_CLASS, factoryClass, target);
+        Reflect.defineMetadata(exports.FACTORY_MODULE, moduleClass, target);
+        return target;
     };
 }

package/dist/entities/document.entity.d.ts

@@ -4,7 +4,7 @@ import type { JSONSchemaConfigType } from '@loopstack/contracts/types';
 export declare class DocumentEntity<T = any> {
     id: string;
     messageId: string;
-    configKey: string;
+    blockName: string;
     workspaceId: string;
     pipelineId: string;
     content: T | null;

package/dist/entities/document.entity.js

@@ -16,7 +16,7 @@ const utils_1 = require("../utils");
 let DocumentEntity = class DocumentEntity {
     id;
     messageId;
-    configKey;
+    blockName;
     workspaceId;
     pipelineId;
     content;
@@ -51,10 +51,10 @@ __decorate([
     __metadata("design:type", String)
 ], DocumentEntity.prototype, "messageId", void 0);
 __decorate([
-    (0, typeorm_1.Column)({ type: 'varchar', name: 'config_key' }),
+    (0, typeorm_1.Column)({ type: 'varchar', name: 'block_name' }),
     (0, typeorm_1.Index)(),
     __metadata("design:type", String)
-], DocumentEntity.prototype, "configKey", void 0);
+], DocumentEntity.prototype, "blockName", void 0);
 __decorate([
     (0, typeorm_1.Column)({ name: 'workspace_id' }),
     (0, typeorm_1.Index)(),

package/dist/entities/pipeline.entity.d.ts

@@ -5,7 +5,7 @@ import { z } from 'zod';
 import type { JSONSchemaConfigType } from '@loopstack/contracts/types';
 export declare class PipelineEntity {
     id: string;
-    configKey: string;
+    blockName: string;
     title: string | null;
     run: number;
     labels: string[];

package/dist/entities/pipeline.entity.js

@@ -17,7 +17,7 @@ const enums_1 = require("../enums");
 const utils_1 = require("../utils");
 let PipelineEntity = class PipelineEntity {
     id;
-    configKey;
+    blockName;
     title;
     run;
     labels;
@@ -41,10 +41,10 @@ __decorate([
     __metadata("design:type", String)
 ], PipelineEntity.prototype, "id", void 0);
 __decorate([
-    (0, typeorm_1.Column)({ type: 'varchar', name: 'config_key' }),
+    (0, typeorm_1.Column)({ type: 'varchar', name: 'block_name' }),
     (0, typeorm_1.Index)(),
     __metadata("design:type", String)
-], PipelineEntity.prototype, "configKey", void 0);
+], PipelineEntity.prototype, "blockName", void 0);
 __decorate([
     (0, typeorm_1.Column)({ type: 'varchar', nullable: true }),
     __metadata("design:type", Object)

package/dist/entities/workflow.entity.d.ts

@@ -3,10 +3,10 @@ import { NamespaceEntity } from './namespace.entity';
 import { WorkflowState } from '../enums';
 import { TransitionResultLookup } from '../interfaces';
 import { z } from 'zod';
-import type { HistoryTransition, JSONSchemaConfigType, UiFormType, WorkflowTransitionType } from '@loopstack/contracts/types';
+import type { JSONSchemaConfigType, UiFormType, WorkflowTransitionType } from '@loopstack/contracts/types';
 export declare class WorkflowEntity {
     id: string;
-    configKey: string;
+    blockName: string;
     title: string;
     index: string;
     progress: number;
@@ -19,7 +19,7 @@ export declare class WorkflowEntity {
     transitionResults: TransitionResultLookup | null;
     inputData: Record<string, any>;
     availableTransitions: WorkflowTransitionType[] | null;
-    history: HistoryTransition[] | null;
+    history: any[] | null;
     schema: JSONSchemaConfigType | null;
     error: z.ZodError | null;
     ui: UiFormType | null;

package/dist/entities/workflow.entity.js

@@ -17,7 +17,7 @@ const enums_1 = require("../enums");
 const utils_1 = require("../utils");
 let WorkflowEntity = class WorkflowEntity {
     id;
-    configKey;
+    blockName;
     title;
     index;
     progress;
@@ -30,7 +30,7 @@ let WorkflowEntity = class WorkflowEntity {
     transitionResults;
     inputData;
     availableTransitions;
-    history;
+    history; //todo should be WorkflowMementoDto[]
     schema;
     error;
     ui;
@@ -49,10 +49,10 @@ __decorate([
     __metadata("design:type", String)
 ], WorkflowEntity.prototype, "id", void 0);
 __decorate([
-    (0, typeorm_1.Column)({ type: 'varchar', name: 'config_key' }),
+    (0, typeorm_1.Column)({ type: 'varchar', name: 'block_name' }),
     (0, typeorm_1.Index)(),
     __metadata("design:type", String)
-], WorkflowEntity.prototype, "configKey", void 0);
+], WorkflowEntity.prototype, "blockName", void 0);
 __decorate([
     (0, typeorm_1.Column)({ type: 'varchar', nullable: true }),
     __metadata("design:type", String)

package/dist/entities/workspace.entity.d.ts

@@ -2,7 +2,7 @@ import { PipelineEntity } from './pipeline.entity';
 export declare class WorkspaceEntity {
     id: string;
     title: string;
-    configKey: string;
+    blockName: string;
     createdAt: Date;
     updatedAt: Date;
     pipelines: PipelineEntity[];

package/dist/entities/workspace.entity.js

@@ -16,7 +16,7 @@ const pipeline_entity_1 = require("./pipeline.entity");
 let WorkspaceEntity = class WorkspaceEntity {
     id;
     title;
-    configKey;
+    blockName;
     createdAt;
     updatedAt;
     pipelines;
@@ -32,10 +32,10 @@ __decorate([
     __metadata("design:type", String)
 ], WorkspaceEntity.prototype, "title", void 0);
 __decorate([
-    (0, typeorm_1.Column)({ type: 'varchar', name: 'config_key' }),
+    (0, typeorm_1.Column)({ type: 'varchar', name: 'block_name' }),
     (0, typeorm_1.Index)(),
     __metadata("design:type", String)
-], WorkspaceEntity.prototype, "configKey", void 0);
+], WorkspaceEntity.prototype, "blockName", void 0);
 __decorate([
     (0, typeorm_2.CreateDateColumn)({ name: 'created_at' }),
     __metadata("design:type", Date)

package/dist/interfaces/block.interface.d.ts

@@ -1,22 +1,6 @@
-import { z } from 'zod';
-import { Scope, Type } from '@nestjs/common';
-import type { BlockConfigType, JSONSchemaConfigType } from '@loopstack/contracts/types';
+import type { BlockConfigType } from '@loopstack/contracts/types';
 export interface BlockOptions {
-    scope?: Scope;
-    imports?: any[];
+    type?: string;
     config?: Partial<BlockConfigType>;
     configFile?: string;
-    documentationFile?: string;
-    properties?: z.ZodType;
-    configSchema?: z.ZodType;
-}
-export interface BlockMetadata {
-    imports: Type<any>[];
-    config: BlockConfigType;
-    configFile?: string;
-    properties?: z.ZodType;
-    propertiesSchema?: JSONSchemaConfigType;
-    configSchema?: z.ZodType;
-    inputProperties: string[];
-    outputProperties: string[];
 }

package/dist/interfaces/handler.interface.d.ts

@@ -3,9 +3,9 @@ export interface ToolSideEffects {
     setTransitionPlace?: string;
     addWorkflowDocuments?: DocumentEntity[];
 }
-export type HandlerCallResult = {
+export type ToolResult<TData = any> = {
     type?: 'text' | 'image' | 'file';
-    data?: any;
+    data?: TData;
     error?: string;
     effects?: ToolSideEffects;
 };

package/dist/interfaces/transition-results.types.d.ts

@@ -1,6 +1,6 @@
-import { HandlerCallResult } from './handler.interface';
+import { ToolResult } from './handler.interface';
 export type StepResultLookup = Record<string, any>;
-export type ToolResultLookup = Record<string, HandlerCallResult>;
+export type ToolResultLookup = Record<string, ToolResult>;
 export type TransitionResultLookup = Record<string, {
     toolResults: ToolResultLookup;
 }>;

package/dist/services/block-config-service.d.ts

@@ -0,0 +1,8 @@
+import { Reflector } from '@nestjs/core';
+import { BlockOptions } from '../interfaces';
+export declare class BlockConfigService {
+    private reflector;
+    constructor(reflector: Reflector);
+    getMetadata(): BlockOptions;
+    getConfig(target: object | Function): void;
+}

package/dist/services/block-config-service.js

@@ -0,0 +1,34 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockConfigService = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const decorators_1 = require("../decorators");
+let BlockConfigService = class BlockConfigService {
+    reflector;
+    constructor(reflector) {
+        this.reflector = reflector;
+    }
+    getMetadata() {
+        return this.reflector.get(decorators_1.BLOCK_METADATA_KEY, this.constructor);
+    }
+    getConfig(target) {
+        const constructor = typeof target === 'function' ? target : target.constructor;
+        const metadata = this.getMetadata();
+    }
+};
+exports.BlockConfigService = BlockConfigService;
+exports.BlockConfigService = BlockConfigService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [typeof (_a = typeof core_1.Reflector !== "undefined" && core_1.Reflector) === "function" ? _a : Object])
+], BlockConfigService);

package/dist/utils/block-config.builder.d.ts

@@ -0,0 +1,3 @@
+import { BlockConfigType } from '@loopstack/contracts/types';
+import { BlockOptions } from '../interfaces';
+export declare function buildConfig(options: BlockOptions, type?: string): BlockConfigType;

package/dist/utils/block-config.builder.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildConfig = buildConfig;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const yaml_1 = require("yaml");
+function buildConfig(options, type) {
+    const baseConfig = {
+        ...options.config,
+    };
+    if (options.configFile) {
+        const configSource = loadConfigFile(options.configFile);
+        if (!configSource) {
+            throw new Error(`Could not load config source ${options.configFile}`);
+        }
+        Object.assign(baseConfig, configSource.config);
+    }
+    if (type) {
+        baseConfig.type = type;
+    }
+    return {
+        type: baseConfig.type ?? 'undefined',
+        description: baseConfig.description ?? '',
+        ...baseConfig,
+    };
+}
+function loadConfigFile(filePath) {
+    const raw = fs_1.default.readFileSync(filePath, 'utf8');
+    const config = (0, yaml_1.parse)(raw);
+    return {
+        path: filePath,
+        relativePath: path_1.default.basename(filePath),
+        raw,
+        config,
+    };
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@loopstack/common",
   "displayName": "Loopstack Common Module",
   "description": "A collection of utils and dtos shared between nestjs modules",
-  "version": "0.14.0",
+  "version": "0.15.1",
   "license": "BSL",
   "author": {
     "name": "Jakob Klippel",
@@ -28,10 +28,11 @@
     "typescript": "^5.7.3"
   },
   "dependencies": {
-    "@loopstack/contracts": "^0.14.0",
+    "@loopstack/contracts": "^0.15.0",
     "fast-json-stable-stringify": "^2.1.0",
     "murmurhash": "^2.0.1",
     "reflect-metadata": "^0.2.2",
+    "yaml": "^2.8.1",
     "zod": "^3.25.76"
   }
 }