@transai/connector-runner-hp-indigo 0.2.0

package/libs/connector-runner-hp-indigo/src/index.d.ts

@@ -0,0 +1,4 @@
+export * from './lib/connector-runner-hp-indigo';
+export * from './types';
+export * from './webhook-server';
+export * from './jmf-client';

package/libs/connector-runner-hp-indigo/src/jmf-client.d.ts

@@ -0,0 +1,35 @@
+import { ConnectorSDKInterface } from '@transai/connector-runtime-sdk';
+import { ConnectorConfig } from './types';
+export interface JMFSubscribeConfig {
+    printerUrl: string;
+    channelId?: string;
+    subscriptionUrl: string;
+}
+export interface JMFUnsubscribeConfig {
+    printerUrl: string;
+    channelId?: string;
+}
+export declare class JMFClient {
+    #private;
+    constructor(sdk: ConnectorSDKInterface<ConnectorConfig>);
+    /**
+     * Subscribe to job status notifications from HP Indigo printer
+     * Sends a JMF SubscriptionFilter query to establish a persistent notification channel
+     */
+    subscribe(config: JMFSubscribeConfig): Promise<void>;
+    /**
+     * Unsubscribe from job status notifications
+     * Sends a JMF StopPersistentChannel command to terminate the subscription
+     * Uses provided channelId if available, otherwise falls back to internal state (e.g., after process restart)
+     */
+    unsubscribe(config: JMFUnsubscribeConfig): Promise<void>;
+    /**
+     * Query printer capabilities to check if it supports JMF
+     */
+    queryCapabilities(printerUrl: string): Promise<void>;
+    /**
+     * Check if our subscription/channel is still active on HP Indigo
+     * Uses JMF Query QueueStatus to verify the persistent channel exists
+     */
+    checkSubscriptionHealth(printerUrl: string): Promise<boolean>;
+}

package/libs/connector-runner-hp-indigo/src/lib/connector-runner-hp-indigo.d.ts

@@ -0,0 +1,14 @@
+import { ConnectorInterface, ConnectorRuntimeSDK, ConnectorSDKInterface } from '@transai/connector-runtime-sdk';
+import { ConnectorConfig } from '../types';
+export declare class ConnectorRunnerHpIndigo extends ConnectorRuntimeSDK<ConnectorConfig> {
+    #private;
+    constructor(connector: ConnectorInterface, connectorSDK: ConnectorSDKInterface);
+    init: () => Promise<void>;
+    start: () => Promise<void>;
+    stop: () => Promise<void>;
+    /**
+     * Call this method when a notification is received to update health tracking
+     * This should be called by the webhook server
+     */
+    notificationReceived(): void;
+}

package/libs/connector-runner-hp-indigo/src/types.d.ts

@@ -0,0 +1,24 @@
+import { BaseConnectorConfig } from '@transai/connector-runtime-sdk';
+export interface ConnectorConfig extends BaseConnectorConfig {
+    callbackHost?: string;
+    port?: number;
+    webhookPath?: string;
+    jmf?: {
+        enabled: boolean;
+        printerUrl: string;
+        channelId?: string;
+    };
+}
+export interface HpIndigoJobStatusMessage {
+    jobId: string;
+    jobName: string;
+    jobStatus: string;
+    jobState: string;
+    timestamp: string;
+    printer?: string;
+    owner?: string;
+    pages?: number;
+    sheets?: number;
+    copies?: number;
+    [key: string]: unknown;
+}

package/libs/connector-runner-hp-indigo/src/webhook-server.d.ts

@@ -0,0 +1,14 @@
+import { ConnectorSDKInterface } from '@transai/connector-runtime-sdk';
+import { ConnectorConfig } from './types';
+export declare class WebhookServer {
+    #private;
+    constructor(sdk: ConnectorSDKInterface<ConnectorConfig>);
+    init(): void;
+    start(): void;
+    stop(): void;
+    /**
+     * Set callback to notify when a notification is received
+     * Used for health monitoring
+     */
+    setNotificationCallback(callback: () => void): void;
+}

package/libs/connector-runtime-sdk/src/index.d.ts

@@ -0,0 +1,5 @@
+export * from './lib/types';
+export * from './lib/connector-runtime';
+export * from './lib/connector-runtime.interface';
+export * from './lib/sdk';
+export * from './lib/support';

package/libs/connector-runtime-sdk/src/lib/connector-runtime.d.ts

@@ -0,0 +1,16 @@
+import { ConnectorRuntimeInterface } from './connector-runtime.interface';
+import { ConnectorSDKInterface } from './sdk';
+import { ActionInterface, BaseConnectorConfig, ConnectorInterface, KafkaCallbackResponse, XodJobType } from './types';
+export interface IpcMessage {
+    cmd: string;
+    message: string;
+}
+export declare abstract class ConnectorRuntimeSDK<T extends BaseConnectorConfig = BaseConnectorConfig> implements ConnectorRuntimeInterface {
+    #private;
+    constructor(connector: ConnectorInterface, connectorSDK: ConnectorSDKInterface);
+    init: () => Promise<void>;
+    start: () => Promise<void>;
+    stop: () => Promise<void>;
+    set callbackFunction(callback: (message: XodJobType, action: ActionInterface) => Promise<KafkaCallbackResponse>);
+    protected get connectorSDK(): ConnectorSDKInterface<T>;
+}

package/libs/connector-runtime-sdk/src/lib/connector-runtime.interface.d.ts

@@ -0,0 +1,5 @@
+export interface ConnectorRuntimeInterface {
+    init(): Promise<void>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}

package/libs/connector-runtime-sdk/src/lib/sdk/files.sdk.interface.d.ts

@@ -0,0 +1,19 @@
+export interface FileInfo {
+    type: 'DIRECTORY' | 'FILE';
+    name: string;
+    size: number;
+    modifyTime: Date;
+}
+export interface FileHandleInterface {
+    readonly path: string;
+    get(): Buffer;
+    close(): boolean;
+}
+export interface FilesSDKInterface {
+    list(path: string): Promise<Array<FileInfo>>;
+    read(filePath: string): Promise<FileHandleInterface>;
+    write(filePath: string, data: FileHandleInterface | Buffer | string): Promise<boolean>;
+    delete(path: string): Promise<boolean>;
+    exists(path: string): Promise<boolean>;
+    pathAsDsn(path: string): string;
+}

package/libs/connector-runtime-sdk/src/lib/sdk/http-client.interface.d.ts

@@ -0,0 +1,47 @@
+export interface HttpConfig {
+    baseUrl?: string;
+    contentType?: string;
+    timeout?: number;
+}
+export type HttpRequestOptions<D = string | object> = {
+    headers?: Record<string, string>;
+    params?: Record<string, string | number | boolean>;
+    data?: D;
+    withCredentials?: boolean;
+    responseType?: 'arraybuffer' | 'blob' | 'document' | 'json' | 'text' | 'stream' | 'formdata';
+};
+export type HttpRequestOptionsFormatter<D = string | object> = (requestOptions: HttpRequestOptions<D>, method: HttpMethod, url: string) => Promise<HttpRequestOptions<D>> | HttpRequestOptions<D>;
+export type HttpErrorResponseCallbackRequest<D = string | object> = {
+    client: HttpClientSDKInterface;
+    method: HttpMethod;
+    url: string;
+    options?: HttpRequestOptions<D>;
+};
+export type HttpErrorResponseCallback<R = unknown, D = string | object> = (error: HttpError, request: HttpErrorResponseCallbackRequest<D>) => HttpClientPromise<R>;
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+export type HttpResponseHeader = string | Array<string> | number | boolean | null;
+export type HttpResponse<D = unknown> = {
+    status: number;
+    data: D;
+    headers?: Record<string, HttpResponseHeader>;
+};
+export type HttpError = {
+    status: number;
+    error?: string;
+};
+interface PromiseWithReason<T = unknown, R = unknown> extends Promise<T> {
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: R) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: R) => TResult | PromiseLike<TResult>) | undefined | null): Promise<T | TResult>;
+}
+export type HttpClientPromise<T> = PromiseWithReason<HttpResponse<T>, HttpError>;
+export interface HttpClientSDKInterface {
+    get<R = unknown>(destination: string, options?: HttpRequestOptions): HttpClientPromise<R>;
+    post<R = unknown, D = string | object>(destination: string, data: D, options?: HttpRequestOptions<D>): HttpClientPromise<R>;
+    put<R = unknown, D = string | object>(destination: string, data: D, options?: HttpRequestOptions<D>): HttpClientPromise<R>;
+    patch<R = unknown, D = string | object>(destination: string, data: D, options?: HttpRequestOptions<D>): HttpClientPromise<R>;
+    delete<R = unknown>(destination: string, options?: HttpRequestOptions): HttpClientPromise<R>;
+    request<R = unknown, D = string | object>(method: HttpMethod, url: string, options?: HttpRequestOptions<D>): HttpClientPromise<R>;
+    setRequestOptionsFormatter<D = string | object>(formatter: HttpRequestOptionsFormatter<D>): HttpClientSDKInterface;
+    setErrorResponseHandler<R = unknown, D = string | object>(callback?: HttpErrorResponseCallback<R, D>): HttpClientSDKInterface;
+}
+export {};

package/libs/connector-runtime-sdk/src/lib/sdk/index.d.ts

@@ -0,0 +1,10 @@
+export * from './sdk.interface';
+export * from './http-client.interface';
+export * from './logger.sdk.interface';
+export * from './offset-store.sdk.interface';
+export * from './processing.sdk.interface';
+export * from './receiver.sdk.interface';
+export * from './sender.sdk.interface';
+export * from './telemetry.sdk.interface';
+export * from './templating.sdk.interface';
+export * from './files.sdk.interface';

package/libs/connector-runtime-sdk/src/lib/sdk/logger.sdk.interface.d.ts

@@ -0,0 +1,7 @@
+export interface LoggerSDKInterface {
+    info(...args: Array<unknown>): void;
+    debug(...args: Array<unknown>): void;
+    error(...args: Array<unknown>): void;
+    warn(...args: Array<unknown>): void;
+    verbose(...args: Array<unknown>): void;
+}

package/libs/connector-runtime-sdk/src/lib/sdk/offset-store.sdk.interface.d.ts

@@ -0,0 +1,13 @@
+export interface StoredOffset {
+    timestamp: number;
+    id: number | string;
+    isoDate?: string;
+    date?: string;
+    rawTimestamp?: number | string;
+    [key: string]: string | number | undefined;
+}
+export interface OffsetStoreSDKInterface {
+    getOffset(identifier: string): Promise<StoredOffset>;
+    setOffset(offset: StoredOffset, identifier: string): void;
+    flush(): Promise<void>;
+}

package/libs/connector-runtime-sdk/src/lib/sdk/processing.sdk.interface.d.ts

@@ -0,0 +1,30 @@
+/** The default timeout is 10 minutes */
+export declare const DEFAULT_TIMEOUT_SECONDS: number;
+export interface IntervalHandler {
+    name?: string;
+    onInit?: () => Promise<void> | void;
+    onRun: () => Promise<void> | void;
+    onStop?: () => Promise<void> | void;
+}
+/**
+ * Options for configuring an interval registered via {@link ProcessingSDKInterface.registerInterval}.
+ */
+export type RegisterIntervalOptions = {
+    /**
+     * If true, the handler will be invoked immediately once on registration,
+     * in addition to subsequent scheduled executions.
+     */
+    immediate?: boolean;
+    /**
+     * Optional timeout, in seconds, for the interval.
+     *
+     * This value should be a positive number representing the maximum time,
+     * in seconds, that the interval is allowed to run before being considered
+     * timed out. Callers should not pass 0 or negative values.
+     */
+    timeout?: number;
+};
+export interface ProcessingSDKInterface {
+    registerInterval(intervalSeconds: number, handler: IntervalHandler, options?: RegisterIntervalOptions): Promise<string>;
+    stopInterval(name: string): Promise<void>;
+}

package/libs/connector-runtime-sdk/src/lib/sdk/receiver.sdk.interface.d.ts

@@ -0,0 +1,14 @@
+import { ActionInterface, KafkaCallbackResponse, KafkaCallbackResponseType, XodJobType } from '../types';
+export interface ReceiverSDKInterface {
+    readonly responses: {
+        readonly ok: KafkaCallbackResponseType;
+        readonly created: KafkaCallbackResponseType;
+        readonly badRequest: KafkaCallbackResponseType;
+        readonly unprocessableEntity: KafkaCallbackResponseType;
+        readonly notFound: KafkaCallbackResponseType;
+        readonly internalServerError: KafkaCallbackResponseType;
+    };
+    registerCallback<T extends XodJobType = XodJobType>(callbackFunction: (message: T) => Promise<KafkaCallbackResponse>, eventType?: string, identifier?: string): void;
+    getActionConfig(message: XodJobType): Promise<ActionInterface | null>;
+    emitEventType<T extends XodJobType = XodJobType>(callbackFunction: (message: T) => Promise<KafkaCallbackResponse>): (message: T) => Promise<KafkaCallbackResponse>;
+}

package/libs/connector-runtime-sdk/src/lib/sdk/sdk.interface.d.ts

@@ -0,0 +1,31 @@
+import { BaseConnectorConfig } from '../types';
+import { FilesSDKInterface } from './files.sdk.interface';
+import { HttpClientSDKInterface, HttpConfig } from './http-client.interface';
+import { LoggerSDKInterface } from './logger.sdk.interface';
+import { OffsetStoreSDKInterface } from './offset-store.sdk.interface';
+import { ProcessingSDKInterface } from './processing.sdk.interface';
+import { ReceiverSDKInterface } from './receiver.sdk.interface';
+import { SenderSDKInterface } from './sender.sdk.interface';
+import { TelemetrySDKInterface } from './telemetry.sdk.interface';
+import { TemplatingSDKInterface } from './templating.sdk.interface';
+export interface ConnectorSDKInterface<T = BaseConnectorConfig> {
+    get config(): T;
+    get logger(): LoggerSDKInterface;
+    get sender(): SenderSDKInterface;
+    get receiver(): ReceiverSDKInterface;
+    get templating(): TemplatingSDKInterface;
+    /**
+     * Service to schedule and manage processing tasks that need monitoring and retries.
+     */
+    get processing(): ProcessingSDKInterface;
+    get offsetStore(): OffsetStoreSDKInterface;
+    /**
+     * Ability to send telemetry data such as gauges and increments on how the connector is performing.
+     */
+    get telemetry(): TelemetrySDKInterface;
+    /**
+     * Get file service instance to access files using a specified DSN. If no DSN is provided, defaults to local file system tmp dir.
+     */
+    files(dsn?: string): FilesSDKInterface;
+    httpClient(httpConfig?: HttpConfig): HttpClientSDKInterface;
+}

package/libs/connector-runtime-sdk/src/lib/sdk/sender.sdk.interface.d.ts

@@ -0,0 +1,27 @@
+export interface Metric {
+    key: string;
+    value: number;
+}
+export type Metadata = {
+    [key: string]: string;
+};
+export type SenderMetadata = {
+    collection?: string;
+    incrementalField?: string;
+    keyField?: string;
+};
+export interface Context {
+    timestamp?: Date;
+    ttl?: number;
+    extraPayload?: {
+        [key: string]: string;
+    };
+}
+export type Result = boolean | {
+    [index: number]: boolean;
+};
+export interface SenderSDKInterface {
+    metrics(metrics: Array<Metric>, metadata?: Metadata & SenderMetadata, context?: Context): Promise<Result>;
+    metricsLegacy<T = never>(metrics: Array<T>, metadata?: Metadata & SenderMetadata, context?: Context, topic?: string): Promise<Result>;
+    documents<T = object>(documents: Array<T>, metadata?: Metadata & SenderMetadata, context?: Context): Promise<Result>;
+}

package/libs/connector-runtime-sdk/src/lib/sdk/telemetry.sdk.interface.d.ts

@@ -0,0 +1,15 @@
+export interface TelemetrySDKInterface {
+    /**
+     * Increment a telemetry counter by 1.
+     */
+    increment(key: string): void;
+    /**
+     * Increment a telemetry counter by a specified value. 0 doesn't send any telemetry.
+     * A negative value will decrement the counter.
+     */
+    increment(key: string, value: number): void;
+    /**
+     * Send a gauge telemetry metric.
+     */
+    gauge(key: string, value: number): void;
+}

package/libs/connector-runtime-sdk/src/lib/sdk/templating.sdk.interface.d.ts

@@ -0,0 +1,12 @@
+export type RuntimeOptions = {
+    partial?: boolean;
+};
+export type CompileDelegate<T = unknown> = {
+    (context: T, options?: RuntimeOptions): string;
+};
+export type CompileOptions = {
+    strict?: boolean;
+};
+export interface TemplatingSDKInterface {
+    compile<T = unknown>(input: string, options?: CompileOptions): CompileDelegate<T>;
+}

package/libs/connector-runtime-sdk/src/lib/support/index.d.ts

@@ -0,0 +1 @@
+export * from './null-logger';

package/libs/connector-runtime-sdk/src/lib/support/null-logger.d.ts

@@ -0,0 +1,8 @@
+import { LoggerSDKInterface } from '../sdk';
+export declare class NullLogger implements LoggerSDKInterface {
+    info(): void;
+    debug(): void;
+    error(): void;
+    warn(): void;
+    verbose(): void;
+}

package/libs/connector-runtime-sdk/src/lib/types/action.d.ts

@@ -0,0 +1,63 @@
+export declare enum ConnectorOrigin {
+    from_template = "from_template",
+    manual = "manual"
+}
+export interface LegacyOutputParameterInterface {
+    [key: string]: string;
+}
+export type SupportedOutputTypes = 'string' | 'number' | 'boolean' | 'array' | 'null';
+export interface OutputItemParameterInterface {
+    type: SupportedOutputTypes | Array<SupportedOutputTypes>;
+    description?: string;
+    required?: boolean;
+}
+export interface ArrayOutputParameterInterface extends OutputItemParameterInterface {
+    type: 'array';
+    items: OutputParameterInterface;
+}
+export interface NumberOutputParameterInterface extends OutputItemParameterInterface {
+    type: 'number' | Array<'number' | 'null'>;
+    minimum?: number;
+    maximum?: number;
+}
+export interface OutputParameterInterface {
+    [key: string]: OutputItemParameterInterface | ArrayOutputParameterInterface | NumberOutputParameterInterface;
+}
+interface BaseInputParameter {
+    name: string;
+    description?: string;
+    required?: boolean;
+}
+export interface ValueInputParameter extends BaseInputParameter {
+    type: 'string' | 'number' | 'boolean';
+}
+export interface SimpleArrayInputParameter extends BaseInputParameter {
+    type: 'simple-array';
+    itemType: 'string' | 'number' | 'boolean';
+}
+export interface ArrayInputParameter extends BaseInputParameter {
+    type: 'array';
+    items: Array<InputParameterInterface>;
+}
+export interface UnknownInputParameter extends BaseInputParameter {
+    type: 'unknown';
+}
+export type InputParameterInterface = ValueInputParameter | SimpleArrayInputParameter | ArrayInputParameter | UnknownInputParameter;
+export interface ActionInterface {
+    identifier: string;
+    version: string;
+    tenantIdentifier: string;
+    name: string;
+    description?: string;
+    connectorIdentifier: string;
+    config: {
+        [key: string]: {
+            [key: string]: string | object;
+        } | string | object;
+    };
+    inputParameters: Array<InputParameterInterface>;
+    outputParameters: LegacyOutputParameterInterface | OutputParameterInterface;
+    mode?: ConnectorOrigin;
+    createdAt: Date;
+}
+export {};

package/libs/connector-runtime-sdk/src/lib/types/kafka.d.ts

@@ -0,0 +1,40 @@
+export interface KafkaBrokerConfig {
+    groupId: string;
+    clientId: string;
+    brokers: Array<string>;
+    sasl?: object;
+    intervalCheckForNewTopics?: number;
+    disableLogs?: boolean;
+    autoCommitThreshold?: number;
+    autoCommitInterval?: number;
+    partitionsConsumedConcurrently?: number;
+    useConfluentLibrary?: boolean;
+    newConsumerProtocol?: boolean;
+}
+export interface KafkaCallbackResponse<T = unknown> {
+    success: boolean;
+    statusCode: number;
+    message: string;
+    payload?: T;
+}
+export type KafkaCallbackResponseType<T = string> = (additionalMessage?: T) => (message: XodBaseMessageType) => Promise<KafkaCallbackResponse>;
+export interface XodBaseMessageType {
+    type: 'ACTION' | 'EVENT' | 'SOURCE' | 'JOB';
+    eventId: string;
+    eventType: string;
+    eventTopic?: string;
+    created: number;
+    payload: object;
+    ttl: number;
+    tenantIdentifier: string;
+    testRun?: boolean;
+    meta?: {
+        [key: string]: unknown;
+    };
+}
+export interface XodJobType extends XodBaseMessageType {
+    type: 'JOB';
+    actionIdentifier: string;
+    actionVersion: string;
+    payload: Record<string, unknown>;
+}

package/libs/connector-runtime-sdk/src/lib/types.d.ts

@@ -0,0 +1,26 @@
+import { ActionInterface, ConnectorOrigin } from './types/action';
+import { KafkaBrokerConfig } from './types/kafka';
+export * from './types/action';
+export * from './types/kafka';
+export interface BaseConnectorConfig {
+    processIdentifier: string;
+    tenantIdentifier: string;
+    datasourceIdentifier: string;
+    kafka: KafkaBrokerConfig;
+    action?: {
+        timeSensitive: boolean;
+    };
+}
+export interface ConnectorInterface<T = Partial<BaseConnectorConfig>> {
+    identifier: string;
+    connectorType: string;
+    tenantIdentifier: string;
+    name: string;
+    location: string;
+    config?: T;
+    enabled: boolean;
+    actions?: Array<ActionInterface>;
+    mode?: ConnectorOrigin;
+    createdAt?: Date;
+    updatedAt?: Date;
+}

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@transai/connector-runner-hp-indigo",
+  "version": "0.2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "LGPL-3.0-or-later",
+  "author": {
+    "name": "transAI",
+    "email": "samen@transai.com",
+    "url": "https://transai.com"
+  },
+  "dependencies": {
+    "express": "^4.0",
+    "xml2js": "^0.6.0"
+  },
+  "type": "commonjs",
+  "main": "./index.cjs",
+  "typings": "./index.d.ts"
+}