@pipe0/ops 0.0.1

package/dist/pipes/utils/errors.d.ts

@@ -0,0 +1,219 @@
+import type { ProviderName } from "../../utils/schemas.js";
+import type { InputGroup, PipeOutputField } from "../catalog/types.js";
+import { type PipeId, type RecordId } from "./schemas-primitives.js";
+export declare function fieldNameStr({ name, resolvedName, }: {
+    name: string;
+    resolvedName: string;
+}): string;
+export declare function inputGroupUnmetMessage(inputGroup: InputGroup): string;
+export type AppError = {
+    code: string;
+    message: string;
+    path?: string;
+};
+export declare class RequestValidationError extends Error {
+    errors: string[];
+    constructor(errors: string[]);
+}
+export declare const validationErrorMessages: {
+    ConditionTargetFieldNotFound: ({ fieldName, pipeId, pipeIdx, }: {
+        fieldName: string;
+        pipeId: PipeId;
+        pipeIdx: number;
+    }) => {
+        code: string;
+        message: string;
+    };
+    FaultyEnrichmentOrder: () => {
+        code: string;
+        message: string;
+    };
+    MustDefineAnnotations: () => {
+        code: string;
+        message: string;
+    };
+    CircularDependency: ({ currentPipe, circularPipe, }: {
+        currentPipe: {
+            idx: number;
+            pipe_id: PipeId | undefined;
+        };
+        circularPipe: {
+            idx: number;
+            pipeId: PipeId | undefined;
+        };
+    }) => {
+        code: string;
+        message: string;
+    };
+    ValidationFailed: ({ error }: {
+        error: unknown;
+    }) => {
+        code: string;
+        message: string;
+    };
+    MissingCustomConnections: ({ pipeId, index, missingProviders, }: {
+        pipeId: PipeId;
+        index: number;
+        missingProviders: ProviderName[];
+    }) => {
+        code: string;
+        message: string;
+    };
+    ResponseGenerationFailed: ({ error }: {
+        error: unknown;
+    }) => {
+        code: string;
+        message: string;
+    };
+    InputValuesMustHaveSameType: ({ pipeId, fieldNames, }: {
+        pipeId: PipeId;
+        fieldNames: string[];
+    }) => {
+        code: string;
+        message: string;
+    };
+    NotValidated: () => {
+        code: string;
+        message: string;
+    };
+    MissingIdInInput: () => {
+        code: string;
+        message: string;
+    };
+    InputDataTypeMismatch: ({ key, derivedInputFieldType, fieldType, }: {
+        key: string;
+        fieldType: string | undefined;
+        derivedInputFieldType: string | undefined;
+    }) => {
+        code: string;
+        message: string;
+    };
+    UnresolvableDependency: ({ index, dependencyIndex, }: {
+        index: number;
+        dependencyIndex: number;
+    }) => {
+        code: string;
+        message: string;
+    };
+    InputGroupRequirementUnmet: ({ inputGroup }: {
+        inputGroup: InputGroup;
+    }) => {
+        code: string;
+        message: string;
+    };
+    HardInputDependencyViolation: ({ index, indexPipeId, dependencyIndex, dependencyIndexPipeId, }: {
+        index: number;
+        indexPipeId: PipeId | undefined;
+        dependencyIndex: number;
+        dependencyIndexPipeId: PipeId | undefined;
+    }) => {
+        code: string;
+        message: string;
+    };
+    HardConditionDependencyViolation: ({ index, indexPipeId, dependencyIndex, dependencyIndexPipeId, }: {
+        index: number;
+        indexPipeId: PipeId | undefined;
+        dependencyIndex: number;
+        dependencyIndexPipeId: PipeId | undefined;
+    }) => {
+        code: string;
+        message: string;
+    };
+    DuplicateInitialField: ({ name }: {
+        name: string;
+    }) => {
+        code: string;
+        message: string;
+    };
+    MissingInputId: ({ index }: {
+        index: number;
+    }) => {
+        code: string;
+        message: string;
+    };
+    InvalidId: () => {
+        code: string;
+        message: string;
+    };
+    IDConflict: ({ index, id }: {
+        index: number;
+        id: RecordId;
+    }) => {
+        code: string;
+        message: string;
+    };
+    UnknownResolver: ({ pipeId, index }: {
+        pipeId: PipeId;
+        index: number;
+    }) => {
+        code: string;
+        message: string;
+    };
+    DuplicatePipeOutput: ({ pipeId, outputField, }: {
+        pipeId: PipeId;
+        outputField: PipeOutputField;
+    }) => {
+        code: string;
+        message: string;
+    };
+    InputDataDoesNotMatchOutputField: ({ index, resolvedName, type, inputValueType, }: {
+        index: number;
+        resolvedName: string;
+        type: string;
+        inputValueType: string;
+    }) => {
+        code: string;
+        message: string;
+    };
+    AmbiguousDependency: ({ fieldName }: {
+        fieldName: string;
+    }) => {
+        code: string;
+        message: string;
+    };
+    EmptyObjectProperty: () => {
+        code: string;
+        message: string;
+    };
+    JSONSchemaMissing: ({ schemaRef, outputName, }: {
+        schemaRef: string | undefined;
+        outputName: string;
+    }) => {
+        code: string;
+        message: string;
+    };
+    InvalidJSONSchema: ({ schemaRef }: {
+        schemaRef: string;
+    }) => {
+        code: string;
+        message: string;
+    };
+    MissingOutputFieldDescription: ({ outputName }: {
+        outputName: string;
+    }) => {
+        code: string;
+        message: string;
+    };
+    InvalidFormatTag: ({ outputName, format, }: {
+        outputName: string;
+        format: string;
+    }) => {
+        code: string;
+        message: string;
+    };
+    RecursiveExpandedValue: () => {
+        code: string;
+        message: string;
+    };
+};
+export declare class Pipe0Error extends Error {
+}
+export declare class PipelineValidationError extends Pipe0Error {
+    errors: AppError[];
+    codes: string[];
+    appErrors: {
+        message: string;
+        path?: string;
+    }[];
+    constructor(errors: AppError[]);
+}

package/dist/pipes/utils/get-json-values.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/pipes/utils/helpers-widgets.d.ts

@@ -0,0 +1,17 @@
+import type { Widgets } from "@pipe0/ops";
+export declare function getFaviconUrlGoogle(domain: string, size?: number): string;
+export declare function ifDefined<A, T>(value: A, cb: (_a: NonNullable<A>) => T): T | undefined;
+export declare function entityLogoProfessionalProfileUrl(): {
+    image_url: string;
+    entity: string;
+} | undefined;
+export declare function entityLogoFavicon({ companyWebsiteUrl, entity, }: {
+    companyWebsiteUrl?: string | null;
+    entity?: string | null;
+}): Widgets["entity_logo"] | undefined;
+/**
+ *
+ * @param destination If key is NOT set on destination it can be added by source. Source will NEVER replace.
+ * @param source Keys to add. Source keys don't overwrite destination keys
+ */
+export declare function mergeWidgets(destination: Widgets, source?: Widgets): Widgets;

package/dist/pipes/utils/helpers.d.ts

@@ -0,0 +1,13 @@
+import type { RecordField } from "./schemas-primitives.js";
+export declare function getFieldDisplayLabel(field: RecordField): string | undefined;
+export declare function testPrint(value: unknown): void;
+export declare function stringify(v: unknown): unknown;
+export declare function rateLimitRationFallingProgression(index: number): number;
+export declare function sortObjectKeys(obj: any): any;
+export declare const TYPES_TO_FORMATS: {
+    string: ("email" | "address_line_1" | "zip_code" | "profile_url" | "phone" | "website_url" | "date" | "url" | "datetime" | "markdown" | "text")[];
+    json: ("json_object" | "json_list")[];
+    number: ("int" | "decimal")[];
+    boolean: never[];
+    unknown: never[];
+};

package/dist/pipes/utils/input-groups-satisfied.d.ts

@@ -0,0 +1,13 @@
+import type { InputGroup, PipeInputField } from "../catalog/types.js";
+import type { PipesRecord, RecordField } from "./schemas-primitives.js";
+type InputGroupsSatisfiedReturn = {
+    valid: true;
+    failedPipeInputField: null;
+    failedRecordField: null;
+} | {
+    valid: false;
+    failedPipeInputField: PipeInputField;
+    failedRecordField: RecordField;
+};
+export declare function inputGroupsSatisfied(record: PipesRecord, inputGroups: InputGroup[]): InputGroupsSatisfiedReturn;
+export {};

package/dist/pipes/utils/parse-prompt-tags.d.ts

@@ -0,0 +1,41 @@
+import { Ajv } from "ajv";
+import type { InputGroup, PipeOutputField } from "../catalog/types.js";
+import { type RecordField, type RecordFieldFormat } from "./schemas-primitives.js";
+import type { AppJsonSchema } from "./types.js";
+export declare const ajv: Ajv;
+export type FieldType = RecordField["type"];
+interface ParsedInputTag {
+    kind: "input";
+    name: string;
+    type: Exclude<FieldType, "json">;
+    required: boolean;
+}
+interface ParsedOutputTag {
+    kind: "output";
+    name: string;
+    type: FieldType;
+    description: string;
+    required: boolean;
+    schemaRef?: string;
+    format?: RecordFieldFormat;
+}
+export declare function parsePromptTemplate({ template, jsonSchemas, supportedTags, transformInputTags, transformOutputTags, }: {
+    template: string;
+    jsonSchemas?: Record<string, AppJsonSchema>;
+    supportedTags?: ("input" | "output")[];
+    transformOutputTags?: (_: ParsedOutputTag) => ParsedOutputTag;
+    transformInputTags?: (_: ParsedInputTag) => ParsedInputTag;
+}): {
+    inputs: ParsedInputTag[];
+    outputs: ParsedOutputTag[];
+    jsonSchemas?: Record<string, AppJsonSchema>;
+};
+export declare function parsedFieldsToPipeIO({ inputs, outputs, jsonSchemas, }: {
+    inputs: ParsedInputTag[];
+    outputs: ParsedOutputTag[];
+    jsonSchemas?: Record<string, AppJsonSchema>;
+}): {
+    inputGroups: InputGroup[];
+    outputFields: Record<string, PipeOutputField>;
+};
+export {};