@rdfc/js-runner 1.0.0 → 2.0.0-alpha.10

package/dist/connectors/file.js

@@ -1,89 +1,89 @@
-import { createReadStream, openSync } from "fs";
-import { appendFile, readFile, stat, writeFile } from "fs/promises";
-import { isAbsolute } from "path";
-import { watch } from "node:fs";
-import { SimpleStream, } from "../connectors.js";
+import { createReadStream, openSync } from 'fs'
+import { appendFile, readFile, stat, writeFile } from 'fs/promises'
+import { isAbsolute } from 'path'
+import { watch } from 'node:fs'
+import { SimpleStream } from '../connectors.js'
 async function getFileSize(path) {
-    return (await stat(path)).size;
+  return (await stat(path)).size
 }
 function readPart(path, start, end, encoding) {
-    return new Promise((res) => {
-        const stream = createReadStream(path, { encoding, start, end });
-        let buffer = "";
-        stream.on("data", (chunk) => {
-            buffer += chunk;
-        });
-        stream.on("close", () => res(buffer));
-    });
+  return new Promise((res) => {
+    const stream = createReadStream(path, { encoding, start, end })
+    let buffer = ''
+    stream.on('data', (chunk) => {
+      buffer += chunk
+    })
+    stream.on('close', () => res(buffer))
+  })
 }
 function debounce(func, timeout = 100) {
-    let timer;
-    return (...args) => {
-        clearTimeout(timer);
-        timer = setTimeout(() => {
-            func(...args);
-        }, timeout);
-    };
+  let timer
+  return (...args) => {
+    clearTimeout(timer)
+    timer = setTimeout(() => {
+      func(...args)
+    }, timeout)
+  }
 }
 export const startFileStreamReader = (config) => {
-    const path = isAbsolute(config.path)
-        ? config.path
-        : `${process.cwd()}/${config.path}`;
-    openSync(path, "a+");
-    const encoding = config.encoding || "utf-8";
-    const reader = new SimpleStream();
-    const init = async () => {
-        let currentPos = await getFileSize(path);
-        const watcher = watch(path, { encoding: "utf-8" });
-        watcher.on("change", debounce(async () => {
-            try {
-                let content;
-                if (config.onReplace) {
-                    content = await readFile(path, { encoding });
-                }
-                else {
-                    const newSize = await getFileSize(path);
-                    if (newSize <= currentPos) {
-                        currentPos = newSize;
-                        return;
-                    }
-                    content = await readPart(path, currentPos, newSize, encoding);
-                    currentPos = newSize;
-                }
-                await reader.push(content);
+  const path = isAbsolute(config.path)
+    ? config.path
+    : `${process.cwd()}/${config.path}`
+  openSync(path, 'a+')
+  const encoding = config.encoding || 'utf-8'
+  const reader = new SimpleStream()
+  const init = async () => {
+    let currentPos = await getFileSize(path)
+    const watcher = watch(path, { encoding: 'utf-8' })
+    watcher.on(
+      'change',
+      debounce(async () => {
+        try {
+          let content
+          if (config.onReplace) {
+            content = await readFile(path, { encoding })
+          } else {
+            const newSize = await getFileSize(path)
+            if (newSize <= currentPos) {
+              currentPos = newSize
+              return
             }
-            catch (error) {
-                if (error.code === "ENOENT") {
-                    return;
-                }
-                throw error;
-            }
-        }));
-        if (config.onReplace && config.readFirstContent) {
-            const content = await readFile(path, { encoding });
-            await reader.push(content);
+            content = await readPart(path, currentPos, newSize, encoding)
+            currentPos = newSize
+          }
+          await reader.push(content)
+        } catch (error) {
+          if (error.code === 'ENOENT') {
+            return
+          }
+          throw error
         }
-    };
-    return { reader, init };
-};
+      }),
+    )
+    if (config.onReplace && config.readFirstContent) {
+      const content = await readFile(path, { encoding })
+      await reader.push(content)
+    }
+  }
+  return { reader, init }
+}
 export const startFileStreamWriter = (config) => {
-    const path = isAbsolute(config.path)
-        ? config.path
-        : `${process.cwd()}/${config.path}`;
-    const encoding = config.encoding || "utf-8";
-    const writer = new SimpleStream();
-    const init = async () => {
-        if (!config.onReplace) {
-            await writeFile(path, "", { encoding });
-        }
-    };
-    writer.push = async (item) => {
-        if (config.onReplace) {
-            await writeFile(path, item, { encoding });
-        }
-        else {
-            await appendFile(path, item, { encoding });
-        }
-    };
-    return { writer, init };
-};
+  const path = isAbsolute(config.path)
+    ? config.path
+    : `${process.cwd()}/${config.path}`
+  const encoding = config.encoding || 'utf-8'
+  const writer = new SimpleStream()
+  const init = async () => {
+    if (!config.onReplace) {
+      await writeFile(path, '', { encoding })
+    }
+  }
+  writer.push = async (item) => {
+    if (config.onReplace) {
+      await writeFile(path, item, { encoding })
+    } else {
+      await appendFile(path, item, { encoding })
+    }
+  }
+  return { writer, init }
+}

package/dist/connectors/http.d.ts

@@ -1,14 +1,14 @@
-import { ReaderConstructor, WriterConstructor } from "../connectors.js";
+import { ReaderConstructor, WriterConstructor } from '../connectors.js'
 export interface HttpReaderConfig {
-    endpoint: string;
-    port: number;
-    binary: boolean;
-    waitHandled?: boolean;
-    responseCode?: number;
+  endpoint: string
+  port: number
+  binary: boolean
+  waitHandled?: boolean
+  responseCode?: number
 }
-export declare const startHttpStreamReader: ReaderConstructor<HttpReaderConfig>;
+export declare const startHttpStreamReader: ReaderConstructor<HttpReaderConfig>
 export interface HttpWriterConfig {
-    endpoint: string;
-    method: string;
+  endpoint: string
+  method: string
 }
-export declare const startHttpStreamWriter: WriterConstructor<HttpWriterConfig>;
+export declare const startHttpStreamWriter: WriterConstructor<HttpWriterConfig>

package/dist/connectors/http.js

@@ -1,82 +1,82 @@
-import * as http from "http";
-import { createServer } from "http";
-import { SimpleStream, } from "../connectors.js";
+import * as http from 'http'
+import { createServer } from 'http'
+import { SimpleStream } from '../connectors.js'
 function streamToString(stream, binary) {
-    const datas = [];
-    return new Promise((res) => {
-        stream.on("data", (data) => {
-            datas.push(data);
-        });
-        stream.on("end", () => {
-            const streamData = Buffer.concat(datas);
-            res(binary ? streamData : streamData.toString());
-        });
-    });
+  const datas = []
+  return new Promise((res) => {
+    stream.on('data', (data) => {
+      datas.push(data)
+    })
+    stream.on('end', () => {
+      const streamData = Buffer.concat(datas)
+      res(binary ? streamData : streamData.toString())
+    })
+  })
 }
 export const startHttpStreamReader = (config) => {
-    let server = undefined;
-    const stream = new SimpleStream(() => new Promise((res) => {
+  let server = undefined
+  const stream = new SimpleStream(
+    () =>
+      new Promise((res) => {
         if (server !== undefined) {
-            server.close(() => {
-                res();
-            });
-        }
-        else {
-            res();
-        }
-    }));
-    const requestListener = async function (req, res) {
-        try {
-            const content = await streamToString(req, config.binary);
-            const promise = stream.push(content).catch((error) => {
-                throw error;
-            });
-            if (config.waitHandled) {
-                await promise;
-            }
-        }
-        catch (error) {
-            console.error("Failed", error);
+          server.close(() => {
+            res()
+          })
+        } else {
+          res()
         }
-        res.writeHead(config.responseCode || 200);
-        res.end("OK");
-    };
-    server = createServer(requestListener);
-    const init = () => {
-        return new Promise((res) => {
-            const cb = () => res(undefined);
-            if (server) {
-                server.listen(config.port, config.endpoint, cb);
-            }
-            else {
-                cb();
-            }
-        });
-    };
-    return { reader: stream, init };
-};
+      }),
+  )
+  const requestListener = async function (req, res) {
+    try {
+      const content = await streamToString(req, config.binary)
+      const promise = stream.push(content).catch((error) => {
+        throw error
+      })
+      if (config.waitHandled) {
+        await promise
+      }
+    } catch (error) {
+      console.error('Failed', error)
+    }
+    res.writeHead(config.responseCode || 200)
+    res.end('OK')
+  }
+  server = createServer(requestListener)
+  const init = () => {
+    return new Promise((res) => {
+      const cb = () => res(undefined)
+      if (server) {
+        server.listen(config.port, config.endpoint, cb)
+      } else {
+        cb()
+      }
+    })
+  }
+  return { reader: stream, init }
+}
 export const startHttpStreamWriter = (config) => {
-    const requestConfig = new URL(config.endpoint);
-    const writer = new SimpleStream();
-    writer.push = async (item) => {
-        await new Promise((resolve) => {
-            const options = {
-                hostname: requestConfig.hostname,
-                path: requestConfig.path,
-                method: config.method,
-                port: requestConfig.port,
-            };
-            const cb = (response) => {
-                response.on("data", () => { });
-                response.on("end", () => {
-                    resolve(null);
-                });
-            };
-            const req = http.request(options, cb);
-            req.write(item, () => {
-                req.end();
-            });
-        });
-    };
-    return { writer, init: async () => { } };
-};
+  const requestConfig = new URL(config.endpoint)
+  const writer = new SimpleStream()
+  writer.push = async (item) => {
+    await new Promise((resolve) => {
+      const options = {
+        hostname: requestConfig.hostname,
+        path: requestConfig.path,
+        method: config.method,
+        port: requestConfig.port,
+      }
+      const cb = (response) => {
+        response.on('data', () => {})
+        response.on('end', () => {
+          resolve(null)
+        })
+      }
+      const req = http.request(options, cb)
+      req.write(item, () => {
+        req.end()
+      })
+    })
+  }
+  return { writer, init: async () => {} }
+}

package/dist/connectors/kafka.d.ts

@@ -1,48 +1,48 @@
-import type { ProducerConfig } from "kafkajs";
-import { ReaderConstructor, WriterConstructor } from "../connectors.js";
+import type { ProducerConfig } from 'kafkajs'
+import { ReaderConstructor, WriterConstructor } from '../connectors.js'
 export interface SASLOptions {
-    mechanism: "plain";
-    username: string;
-    password: string;
+  mechanism: 'plain'
+  username: string
+  password: string
 }
 export interface BrokerConfig {
-    hosts: string[];
-    ssl?: boolean;
-    sasl?: SASLOptions;
+  hosts: string[]
+  ssl?: boolean
+  sasl?: SASLOptions
 }
 export interface ConsumerConfig {
-    groupId: string;
-    metadataMaxAge?: number;
-    sessionTimeout?: number;
-    rebalanceTimeout?: number;
-    heartbeatInterval?: number;
-    maxBytesPerPartition?: number;
-    minBytes?: number;
-    maxBytes?: number;
-    maxWaitTimeInMs?: number;
-    allowAutoTopicCreation?: boolean;
-    maxInFlightRequests?: number;
-    readUncommitted?: boolean;
-    rackId?: string;
+  groupId: string
+  metadataMaxAge?: number
+  sessionTimeout?: number
+  rebalanceTimeout?: number
+  heartbeatInterval?: number
+  maxBytesPerPartition?: number
+  minBytes?: number
+  maxBytes?: number
+  maxWaitTimeInMs?: number
+  allowAutoTopicCreation?: boolean
+  maxInFlightRequests?: number
+  readUncommitted?: boolean
+  rackId?: string
 }
 export interface CSTopic {
-    topic: string;
-    fromBeginning?: boolean;
+  topic: string
+  fromBeginning?: boolean
 }
 export interface KafkaReaderConfig {
-    topic: {
-        name: string;
-        fromBeginning?: boolean;
-    };
-    consumer: ConsumerConfig;
-    broker: string | BrokerConfig;
+  topic: {
+    name: string
+    fromBeginning?: boolean
+  }
+  consumer: ConsumerConfig
+  broker: string | BrokerConfig
 }
-export declare const startKafkaStreamReader: ReaderConstructor<KafkaReaderConfig>;
+export declare const startKafkaStreamReader: ReaderConstructor<KafkaReaderConfig>
 export interface KafkaWriterConfig {
-    topic: {
-        name: string;
-    };
-    producer: ProducerConfig;
-    broker: BrokerConfig | string;
+  topic: {
+    name: string
+  }
+  producer: ProducerConfig
+  broker: BrokerConfig | string
 }
-export declare const startKafkaStreamWriter: WriterConstructor<KafkaWriterConfig>;
+export declare const startKafkaStreamWriter: WriterConstructor<KafkaWriterConfig>

package/dist/connectors/kafka.js

@@ -1,64 +1,68 @@
-import { readFileSync } from "node:fs";
-import { Kafka } from "kafkajs";
-import { SimpleStream, } from "../connectors.js";
+import { readFileSync } from 'node:fs'
+import { Kafka } from 'kafkajs'
+import { SimpleStream } from '../connectors.js'
 export const startKafkaStreamReader = (config) => {
-    const brokerConfig = {};
-    if (typeof config.broker === "string" || config.broker instanceof String) {
-        Object.assign(brokerConfig, JSON.parse(readFileSync(config.broker, "utf-8")));
-    }
-    else {
-        Object.assign(brokerConfig, config.broker);
-    }
-    if (brokerConfig && brokerConfig.hosts) {
-        brokerConfig.brokers = (brokerConfig).hosts;
-    }
-    const kafka = new Kafka(brokerConfig);
-    const consumer = kafka.consumer(config.consumer);
-    const stream = new SimpleStream(async () => {
-        await consumer.disconnect();
-        await consumer.stop();
-    });
-    const init = async () => {
-        await consumer.connect();
-        await consumer.subscribe({
-            topic: config.topic.name,
-            fromBeginning: config.topic.fromBeginning,
-        });
-        consumer
-            .run({
-            async eachMessage({ topic, message, }) {
-                if (topic === config.topic.name) {
-                    const element = message.value?.toString() ?? "";
-                    await stream.push(element);
-                }
-            },
-        })
-            .catch((error) => {
-            throw error;
-        });
-    };
-    return { reader: stream, init };
-};
+  const brokerConfig = {}
+  if (typeof config.broker === 'string' || config.broker instanceof String) {
+    Object.assign(
+      brokerConfig,
+      JSON.parse(readFileSync(config.broker, 'utf-8')),
+    )
+  } else {
+    Object.assign(brokerConfig, config.broker)
+  }
+  if (brokerConfig && brokerConfig.hosts) {
+    brokerConfig.brokers = brokerConfig.hosts
+  }
+  const kafka = new Kafka(brokerConfig)
+  const consumer = kafka.consumer(config.consumer)
+  const stream = new SimpleStream(async () => {
+    await consumer.disconnect()
+    await consumer.stop()
+  })
+  const init = async () => {
+    await consumer.connect()
+    await consumer.subscribe({
+      topic: config.topic.name,
+      fromBeginning: config.topic.fromBeginning,
+    })
+    consumer
+      .run({
+        async eachMessage({ topic, message }) {
+          if (topic === config.topic.name) {
+            const element = message.value?.toString() ?? ''
+            await stream.push(element)
+          }
+        },
+      })
+      .catch((error) => {
+        throw error
+      })
+  }
+  return { reader: stream, init }
+}
 export const startKafkaStreamWriter = (config) => {
-    const topic = config.topic.name;
-    const brokerConfig = {};
-    if (typeof config.broker === "string" || config.broker instanceof String) {
-        Object.assign(brokerConfig, JSON.parse(readFileSync(config.broker, "utf-8")));
-    }
-    else {
-        Object.assign(brokerConfig, config.broker);
-    }
-    if (brokerConfig && brokerConfig.hosts) {
-        brokerConfig.brokers = (brokerConfig).hosts;
-    }
-    const kafka = new Kafka(brokerConfig);
-    const producer = kafka.producer(config.producer);
-    const writer = new SimpleStream(async () => {
-        await producer.disconnect();
-    });
-    const init = () => producer.connect();
-    writer.push = async (item) => {
-        await producer.send({ topic, messages: [{ value: item }] });
-    };
-    return { writer, init };
-};
+  const topic = config.topic.name
+  const brokerConfig = {}
+  if (typeof config.broker === 'string' || config.broker instanceof String) {
+    Object.assign(
+      brokerConfig,
+      JSON.parse(readFileSync(config.broker, 'utf-8')),
+    )
+  } else {
+    Object.assign(brokerConfig, config.broker)
+  }
+  if (brokerConfig && brokerConfig.hosts) {
+    brokerConfig.brokers = brokerConfig.hosts
+  }
+  const kafka = new Kafka(brokerConfig)
+  const producer = kafka.producer(config.producer)
+  const writer = new SimpleStream(async () => {
+    await producer.disconnect()
+  })
+  const init = () => producer.connect()
+  writer.push = async (item) => {
+    await producer.send({ topic, messages: [{ value: item }] })
+  }
+  return { writer, init }
+}

package/dist/connectors/ws.d.ts

@@ -1,10 +1,10 @@
-import { ReaderConstructor, WriterConstructor } from "../connectors.js";
+import { ReaderConstructor, WriterConstructor } from '../connectors.js'
 export interface WsWriterConfig {
-    url: string;
+  url: string
 }
 export interface WsReaderConfig {
-    host: string;
-    port: number;
+  host: string
+  port: number
 }
-export declare const startWsStreamReader: ReaderConstructor<WsReaderConfig>;
-export declare const startWsStreamWriter: WriterConstructor<WsWriterConfig>;
+export declare const startWsStreamReader: ReaderConstructor<WsReaderConfig>
+export declare const startWsStreamWriter: WriterConstructor<WsWriterConfig>