equipped 5.2.8 → 5.3.0-alpha.0

package/dist/types/dbs/mongo/db.js

@@ -1,224 +0,0 @@
-import { AsyncLocalStorage } from "node:async_hooks";
-import {
-  ClientSession,
-  Collection,
-  MongoClient,
-  ObjectId
-} from "mongodb";
-import { EquippedError } from "../../errors/index.js";
-import { Instance } from "../../instance/index.js";
-import * as core from "../base/core.js";
-import { Db } from "../base/db.js";
-import { MongoDbChange } from "./changes.js";
-import { parseMongodbQueryParams } from "./query.js";
-const idKey = "_id";
-const sessionStore = new AsyncLocalStorage(void 0);
-class MongoDb extends Db {
-  constructor(mongoConfig, dbConfig) {
-    super(dbConfig);
-    this.mongoConfig = mongoConfig;
-    this.client = new MongoClient(mongoConfig.uri, { ignoreUndefined: true });
-    Instance.on(
-      "start",
-      async () => {
-        await this.client.connect();
-        const grouped = this.#cols.reduce((acc, cur) => {
-          if (!acc[cur.db]) acc[cur.db] = [];
-          acc[cur.db].push(cur.col);
-          return acc;
-        }, {});
-        const options = {
-          changeStreamPreAndPostImages: { enabled: true }
-        };
-        await Promise.all(
-          Object.entries(grouped).map(async ([dbName, colNames]) => {
-            const db = this.client.db(dbName);
-            const collections = await db.listCollections().toArray();
-            return colNames.map(async (colName) => {
-              const existing = collections.find((collection) => collection.name === colName);
-              if (existing) {
-                if (existing.options?.changeStreamPreAndPostImages?.enabled !== options.changeStreamPreAndPostImages.enabled)
-                  await db.command({ collMod: colName, ...options });
-              } else await db.createCollection(colName, options);
-            });
-          })
-        );
-      },
-      3
-    );
-    Instance.on("close", async () => this.client.close(), 1);
-  }
-  client;
-  #cols = [];
-  async session(callback) {
-    if (sessionStore.getStore()) return callback();
-    const session = await this.client.startSession();
-    return session.withTransaction(async () => sessionStore.run(session, callback));
-  }
-  id() {
-    return new ObjectId();
-  }
-  use(config) {
-    const db = this.getScopedDb(config.db);
-    this.#cols.push({ db, col: config.col });
-    return this.#getTable(config, this.client.db(db).collection(config.col));
-  }
-  #getTable(config, collection) {
-    async function transform(doc) {
-      const docs = Array.isArray(doc) ? doc : [doc];
-      const mapped = docs.map((d) => config.mapper(d));
-      return Array.isArray(doc) ? mapped : mapped[0];
-    }
-    function prepInsertValue(value, id, now, skipUpdate) {
-      const base = {
-        [idKey]: id,
-        ...config.options?.skipAudit ? {} : {
-          createdAt: now.getTime(),
-          ...skipUpdate ? {} : { updatedAt: now.getTime() }
-        }
-      };
-      return {
-        ...value,
-        ...base
-      };
-    }
-    function prepUpdateValue(value, now, upsert = false) {
-      return {
-        ...value,
-        $set: {
-          ...value.$set,
-          ...upsert || Object.keys(value).length > 0 && !config.options?.skipAudit ? { updatedAt: now.getTime() } : {}
-        }
-      };
-    }
-    const dbThis = this;
-    const table = {
-      config,
-      extras: { collection },
-      query: async (params) => {
-        const results = await parseMongodbQueryParams(collection, params);
-        return {
-          ...results,
-          results: await transform(results.results)
-        };
-      },
-      findMany: async (filter, options = {}) => {
-        const sortArray = Array.isArray(options.sort) ? options.sort : options.sort ? [options.sort] : [];
-        const sort = sortArray.map((p) => [p.field, p.desc ? "desc" : "asc"]);
-        const docs = await collection.find(filter, {
-          session: sessionStore.getStore(),
-          limit: options.limit,
-          sort
-        }).toArray();
-        return transform(docs);
-      },
-      findOne: async (filter) => {
-        const result = await table.findMany(filter, { limit: 1 });
-        return result.at(0) ?? null;
-      },
-      findById: async (id) => {
-        const result = await table.findOne({ [idKey]: id });
-        return result;
-      },
-      insertMany: async (values, options = {}) => {
-        const now = options.getTime?.() ?? /* @__PURE__ */ new Date();
-        const payload = values.map((value, i) => prepInsertValue(value, options.makeId?.(i) ?? new ObjectId().toString(), now));
-        await collection.insertMany(payload, { session: sessionStore.getStore() });
-        const insertedData = await Promise.all(payload.map(async (data) => await table.findById(data[idKey])));
-        return insertedData.filter((value) => !!value);
-      },
-      insertOne: async (values, options = {}) => {
-        const result = await table.insertMany([values], options);
-        return result[0];
-      },
-      updateMany: async (filter, values, options = {}) => {
-        const now = options.getTime?.() ?? /* @__PURE__ */ new Date();
-        const session = sessionStore.getStore();
-        const data = await collection.find(filter, { session, projection: { [idKey]: 1 } }).toArray();
-        const ids = data.map((doc) => doc[idKey]);
-        const filterUpd = { [idKey]: { $in: ids } };
-        await collection.updateMany(filterUpd, prepUpdateValue(values, now), { session });
-        return table.findMany(filterUpd);
-      },
-      updateOne: async (filter, values, options = {}) => {
-        const now = options.getTime?.() ?? /* @__PURE__ */ new Date();
-        const doc = await collection.findOneAndUpdate(filter, prepUpdateValue(values, now), {
-          returnDocument: "after",
-          session: sessionStore.getStore()
-        });
-        return doc ? transform(doc) : null;
-      },
-      updateById: async (id, values, options = {}) => {
-        const result = await table.updateOne({ [idKey]: id }, values, options);
-        return result;
-      },
-      upsertOne: async (filter, values, options = {}) => {
-        const now = options.getTime?.() ?? /* @__PURE__ */ new Date();
-        const doc = await collection.findOneAndUpdate(
-          filter,
-          {
-            ...prepUpdateValue("update" in values ? values.update : {}, now, true),
-            // @ts-expect-error fighting ts
-            $setOnInsert: prepInsertValue(values.insert, options.makeId?.() ?? new ObjectId().toString(), now, true)
-          },
-          { returnDocument: "after", session: sessionStore.getStore(), upsert: true }
-        );
-        return transform(doc);
-      },
-      deleteMany: async (filter, options = {}) => {
-        const docs = await table.findMany(filter, options);
-        await collection.deleteMany(filter, { session: sessionStore.getStore() });
-        return docs;
-      },
-      deleteOne: async (filter) => {
-        const doc = await collection.findOneAndDelete(filter, { session: sessionStore.getStore() });
-        return doc ? transform(doc) : null;
-      },
-      deleteById: async (id) => {
-        const result = await table.deleteOne({ [idKey]: id });
-        return result;
-      },
-      bulkWrite: async (operations, options = {}) => {
-        const bulk = collection.initializeUnorderedBulkOp({ session: sessionStore.getStore() });
-        const now = options.getTime?.() ?? /* @__PURE__ */ new Date();
-        operations.forEach((operation, i) => {
-          switch (operation.op) {
-            case "insert":
-              bulk.insert(prepInsertValue(operation.value, operation.makeId?.(i) ?? new ObjectId().toString(), now));
-              break;
-            case "delete":
-              bulk.find(operation.filter).delete();
-              break;
-            case "update":
-              bulk.find(operation.filter).update(prepUpdateValue(operation.value, now));
-              break;
-            case "upsert":
-              bulk.find(operation.filter).upsert().update({
-                ...prepUpdateValue("update" in operation ? operation.update : {}, now, true),
-                $setOnInsert: prepInsertValue(
-                  operation.insert,
-                  operation.makeId?.(i) ?? new ObjectId().toString(),
-                  now,
-                  true
-                )
-              });
-              break;
-            default:
-              throw new EquippedError(`Unknown bulkWrite operation`, { operation });
-          }
-        });
-        if (!bulk.length) return;
-        await bulk.execute({ session: sessionStore.getStore() });
-      },
-      watch(callbacks) {
-        if (!dbThis.config.changes)
-          Instance.crash(new EquippedError("Db changes are not enabled in the configuration.", { config }));
-        return new MongoDbChange(dbThis.mongoConfig, dbThis.config.changes, collection, callbacks, config.mapper);
-      }
-    };
-    return table;
-  }
-}
-export {
-  MongoDb
-};

package/dist/types/dbs/mongo/query.js

@@ -1,65 +0,0 @@
-import { Collection } from "mongodb";
-import * as core from "../base/core.js";
-import { QueryKeys } from "../pipes.js";
-const parseMongodbQueryParams = async (collection, params) => {
-  const query = [];
-  const where = buildWhereQuery(params.where, params.whereType);
-  if (where) query.push(where);
-  const auth = buildWhereQuery(params.auth, params.authType);
-  if (auth) query.push(auth);
-  if (params.search && params.search.fields.length > 0) {
-    const search = params.search.fields.map((field) => ({
-      [field]: {
-        $regex: new RegExp(params.search.value, "i")
-      }
-    }));
-    query.push({ $or: search });
-  }
-  const totalClause = {};
-  if (query.length > 0) totalClause["$and"] = query;
-  const sort = params.sort.map((p) => [p.field, p.desc ? "desc" : "asc"]);
-  const all = params.all ?? false;
-  const limit = params.limit;
-  const page = params.page;
-  const total = await collection.countDocuments(totalClause);
-  let builtQuery = collection.find(totalClause);
-  if (sort.length) builtQuery = builtQuery.sort(Object.fromEntries(sort));
-  if (!all && limit) {
-    builtQuery = builtQuery.limit(limit);
-    if (page) builtQuery = builtQuery.skip((page - 1) * limit);
-  }
-  const results = await builtQuery.toArray();
-  const start = 1;
-  const last = Math.ceil(total / limit) || 1;
-  const next = page >= last ? null : page + 1;
-  const previous = page <= start ? null : page - 1;
-  return {
-    pages: { start, last, next, previous, current: page },
-    docs: { limit, total, count: results.length },
-    results
-  };
-};
-function isWhereBlock(param) {
-  return Object.values(QueryKeys).includes(param.condition);
-}
-const buildWhereQuery = (params, key = QueryKeys.and) => {
-  const where = (Array.isArray(params) ? params : []).map((param) => {
-    if (isWhereBlock(param)) return buildWhereQuery(param.value, param.condition);
-    const { field } = param;
-    const checkedField = field === "id" ? "_id" : field ?? "";
-    const checkedValue = param.value === void 0 ? "" : param.value;
-    return {
-      field: checkedField,
-      value: checkedValue,
-      condition: param.condition,
-      isWhere: true
-    };
-  }).filter((c) => !!c).map((c) => {
-    if (c.isWhere) return { [`${c.field}`]: { [`$${c.condition}`]: c.value } };
-    else return c;
-  });
-  return where.length > 0 ? { [`$${key}`]: where } : null;
-};
-export {
-  parseMongodbQueryParams
-};

package/dist/types/dbs/pipes.js

@@ -1,103 +0,0 @@
-import { v } from "valleyed";
-import { Instance } from "../instance/index.js";
-var QueryKeys = /* @__PURE__ */ ((QueryKeys2) => {
-  QueryKeys2["and"] = "and";
-  QueryKeys2["or"] = "or";
-  return QueryKeys2;
-})(QueryKeys || {});
-var Conditions = /* @__PURE__ */ ((Conditions2) => {
-  Conditions2["lt"] = "lt";
-  Conditions2["lte"] = "lte";
-  Conditions2["gt"] = "gt";
-  Conditions2["gte"] = "gte";
-  Conditions2["eq"] = "eq";
-  Conditions2["ne"] = "ne";
-  Conditions2["in"] = "in";
-  Conditions2["nin"] = "nin";
-  Conditions2["exists"] = "exists";
-  return Conditions2;
-})(Conditions || {});
-const queryKeys = v.catch(v.defaults(v.in(["and" /* and */, "or" /* or */]), "and" /* and */), "and" /* and */);
-const queryWhere = v.object({
-  field: v.string(),
-  value: v.any(),
-  condition: v.catch(v.defaults(v.in(Object.values(Conditions)), "eq" /* eq */), "eq" /* eq */)
-});
-const queryWhereBlock = v.recursive(
-  () => v.discriminate((d) => Object.values(QueryKeys).includes(d.condition) ? "block" : "regular", {
-    block: v.object({
-      condition: queryKeys,
-      value: v.array(queryWhereBlock)
-    }),
-    regular: queryWhere
-  }),
-  "QueryWhereBlock"
-);
-const queryWhereClause = v.defaults(v.array(queryWhereBlock), []);
-function queryParamsPipe() {
-  return v.meta(
-    v.object({
-      all: v.defaults(v.boolean(), false),
-      limit: v.lazy(() => {
-        const pagLimit = Instance.get().settings.utils.paginationDefaultLimit;
-        return v.catch(v.defaults(v.number().pipe(v.lte(pagLimit)), pagLimit), pagLimit);
-      }),
-      page: v.catch(v.defaults(v.number().pipe(v.gte(1)), 1), 1),
-      search: v.defaults(
-        v.nullish(
-          v.object({
-            value: v.string(),
-            fields: v.array(v.string())
-          })
-        ),
-        null
-      ),
-      sort: v.defaults(
-        v.array(
-          v.object({
-            field: v.string(),
-            desc: v.defaults(v.boolean(), false)
-          })
-        ),
-        []
-      ),
-      whereType: queryKeys,
-      where: queryWhereClause
-    }).pipe((p) => ({ ...p, auth: [], authType: "and" /* and */ })),
-    { title: "Query Params", $refId: "QueryParams" }
-  );
-}
-function queryResultsPipe(model) {
-  return v.object({
-    pages: v.object({
-      current: v.number(),
-      start: v.number(),
-      last: v.number(),
-      previous: v.nullable(v.number()),
-      next: v.nullable(v.number())
-    }),
-    docs: v.object({
-      limit: v.number(),
-      total: v.number(),
-      count: v.number()
-    }),
-    results: v.array(model)
-  });
-}
-function wrapQueryParams(params) {
-  return v.assert(queryParamsPipe(), params);
-}
-const mongoDbConfigPipe = () => v.meta(
-  v.object({
-    uri: v.string()
-  }),
-  { title: "Mongodb Config", $refId: "MongodbConfig" }
-);
-export {
-  Conditions,
-  QueryKeys,
-  mongoDbConfigPipe,
-  queryParamsPipe,
-  queryResultsPipe,
-  wrapQueryParams
-};

package/dist/types/errors/equippedError.js

@@ -1,11 +0,0 @@
-class EquippedError extends Error {
-  constructor(message, context, cause) {
-    super(message, { cause });
-    this.message = message;
-    this.context = context;
-    this.cause = cause;
-  }
-}
-export {
-  EquippedError
-};

package/dist/types/errors/requestError.js

@@ -1,11 +0,0 @@
-import { EquippedError } from "./equippedError.js";
-class RequestError extends EquippedError {
-  constructor(message, serializedErrors, cause) {
-    super(message, { serializedErrors }, cause);
-    this.message = message;
-    this.serializedErrors = serializedErrors;
-  }
-}
-export {
-  RequestError
-};

package/dist/types/errors/types/badRequestError.js

@@ -1,11 +0,0 @@
-import { StatusCodes } from "../../server/index.js";
-import { RequestError } from "../requestError.js";
-class BadRequestError extends RequestError {
-  statusCode = StatusCodes.BadRequest;
-  constructor(message, cause) {
-    super(message, [{ message }], cause);
-  }
-}
-export {
-  BadRequestError
-};

package/dist/types/errors/types/notAuthenticatedError.js

@@ -1,11 +0,0 @@
-import { StatusCodes } from "../../server/index.js";
-import { RequestError } from "../requestError.js";
-class NotAuthenticatedError extends RequestError {
-  statusCode = StatusCodes.NotAuthenticated;
-  constructor(message = "Not authenticated", cause) {
-    super(message, [{ message }], cause);
-  }
-}
-export {
-  NotAuthenticatedError
-};

package/dist/types/errors/types/notAuthorizedError.js

@@ -1,11 +0,0 @@
-import { StatusCodes } from "../../server/index.js";
-import { RequestError } from "../requestError.js";
-class NotAuthorizedError extends RequestError {
-  statusCode = StatusCodes.NotAuthorized;
-  constructor(message = "Not authorized", cause) {
-    super(message, [{ message }], cause);
-  }
-}
-export {
-  NotAuthorizedError
-};

package/dist/types/errors/types/notFoundError.js

@@ -1,11 +0,0 @@
-import { StatusCodes } from "../../server/index.js";
-import { RequestError } from "../requestError.js";
-class NotFoundError extends RequestError {
-  statusCode = StatusCodes.NotFound;
-  constructor(message = "Not found", cause) {
-    super(message, [{ message }], cause);
-  }
-}
-export {
-  NotFoundError
-};

package/dist/types/errors/types/tokenExpired.js

@@ -1,11 +0,0 @@
-import { StatusCodes } from "../../server/index.js";
-import { RequestError } from "../requestError.js";
-class TokenExpired extends RequestError {
-  statusCode = StatusCodes.TokenExpired;
-  constructor(message = "Token expired", cause) {
-    super(message, [{ message }], cause);
-  }
-}
-export {
-  TokenExpired
-};

package/dist/types/errors/types/validationError.js

@@ -1,15 +0,0 @@
-import { StatusCodes } from "../../server/index.js";
-import { RequestError } from "../requestError.js";
-class ValidationError extends RequestError {
-  statusCode = StatusCodes.ValidationError;
-  constructor(errors, cause) {
-    super(
-      "Unprocessable Entity",
-      errors.flatMap(({ field, messages }) => messages.map((message) => ({ message, field }))),
-      cause
-    );
-  }
-}
-export {
-  ValidationError
-};

package/dist/types/events/base.js

@@ -1,5 +0,0 @@
-class EventBus {
-}
-export {
-  EventBus
-};

package/dist/types/events/pipes.js

@@ -1,27 +0,0 @@
-import { v } from "valleyed";
-const rabbitmqConfigPipe = () => v.meta(
-  v.object({
-    uri: v.string(),
-    eventColumnName: v.string()
-  }),
-  { title: "Rabbitmq Config", $refId: "RabbitmqConfig" }
-);
-const kafkaConfigPipe = () => v.meta(
-  v.object({
-    brokers: v.array(v.string()),
-    ssl: v.optional(v.boolean()),
-    sasl: v.optional(
-      v.object({
-        mechanism: v.is("plain"),
-        username: v.string(),
-        password: v.string()
-      })
-    ),
-    clientId: v.optional(v.string())
-  }),
-  { title: "Kafka Config", $refId: "KafkaConfig" }
-);
-export {
-  kafkaConfigPipe,
-  rabbitmqConfigPipe
-};

package/dist/types/events/types/rabbitmq.js

@@ -1,53 +0,0 @@
-import { connect } from "amqp-connection-manager";
-import { Instance } from "../../instance/index.js";
-import { Random, parseJSONValue } from "../../utilities/index.js";
-import { EventBus } from "../base.js";
-class RabbitMQEventBus extends EventBus {
-  #client;
-  #columnName;
-  constructor(config) {
-    super();
-    this.#columnName = config.eventColumnName;
-    this.#client = connect([config.uri]).createChannel({
-      json: false,
-      setup: async (channel) => {
-        await channel.assertExchange(this.#columnName, "direct", { durable: true });
-        await channel.prefetch(1);
-      }
-    });
-  }
-  createStream(topicName, options = {}) {
-    const topic = options.skipScope ? topicName : Instance.get().getScopedName(topicName);
-    return {
-      publish: async (data) => await this.#client.publish(this.#columnName, topic, JSON.stringify(data), { persistent: true }),
-      subscribe: async (onMessage) => {
-        const subscribe = async () => {
-          await this.#client.addSetup(async (channel) => {
-            const queueName = options.fanout ? Instance.get().getScopedName(`${Instance.get().id}-fanout-${Random.string(10)}`) : topic;
-            const { queue } = await channel.assertQueue(queueName, { durable: !options.fanout, exclusive: options.fanout });
-            await channel.bindQueue(queue, this.#columnName, topic);
-            channel.consume(
-              queue,
-              async (msg) => {
-                await Instance.resolveBeforeCrash(async () => {
-                  if (!msg) return;
-                  try {
-                    await onMessage(parseJSONValue(msg.content.toString()));
-                    channel.ack(msg);
-                  } catch {
-                    channel.nack(msg);
-                  }
-                });
-              },
-              { noAck: false }
-            );
-          });
-        };
-        Instance.on("start", subscribe, 2);
-      }
-    };
-  }
-}
-export {
-  RabbitMQEventBus
-};

package/dist/types/instance/hooks.js

@@ -1,25 +0,0 @@
-async function runHooks(hooks, onError = (error) => {
-  throw error;
-}) {
-  const grouped = hooks.reduce((acc, cur) => {
-    const key = cur.order.toString();
-    if (!acc[key]) acc[key] = [];
-    acc[key].push(cur);
-    return acc;
-  }, {});
-  const groups = Object.keys(grouped).sort((a, b) => parseInt(a) - parseInt(b)).map((key) => grouped[key]);
-  for (const group of groups)
-    await Promise.all(
-      group.map(async (h) => {
-        try {
-          if (typeof h.cb === "function") return await h.cb();
-          return await h.cb;
-        } catch (error) {
-          return onError(error instanceof Error ? error : new Error(`${error}`));
-        }
-      })
-    );
-}
-export {
-  runHooks
-};

package/dist/types/instance/settings.js

@@ -1,56 +0,0 @@
-import { v } from "valleyed";
-import { InMemoryCache, RedisCache, redisConfigPipe } from "../cache/index.js";
-import { MongoDb, mongoDbConfigPipe } from "../dbs/index.js";
-import { KafkaEventBus, RabbitMQEventBus, kafkaConfigPipe, rabbitmqConfigPipe } from "../events/index.js";
-import { RedisJob, redisJobsConfigPipe } from "../jobs/index.js";
-import { ExpressServer, FastifyServer, serverConfigPipe } from "../server/index.js";
-const instanceSettingsPipe = () => v.object({
-  app: v.object({
-    name: v.string()
-  }),
-  log: v.defaults(
-    v.object({
-      level: v.defaults(v.in(["fatal", "error", "warn", "info", "debug", "trace", "silent"]), "info")
-    }),
-    {}
-  ),
-  utils: v.defaults(
-    v.object({
-      hashSaltRounds: v.defaults(v.number(), 10),
-      paginationDefaultLimit: v.defaults(v.number(), 100),
-      maxFileUploadSizeInMb: v.defaults(v.number(), 500)
-    }),
-    {}
-  )
-});
-const cachePipe = () => v.discriminate((e) => e?.type, {
-  "in-memory": v.object({ type: v.is("in-memory") }).pipe(() => new InMemoryCache()),
-  redis: v.merge(redisConfigPipe(), v.object({ type: v.is("redis") })).pipe(({ type: _, ...config }) => new RedisCache(config))
-});
-const jobsPipe = () => v.discriminate((e) => e?.type, {
-  redis: v.merge(redisJobsConfigPipe(), v.object({ type: v.is("redis") })).pipe(({ type: _, ...config }) => new RedisJob(config))
-});
-const eventBusPipe = () => v.discriminate((e) => e?.type, {
-  kafka: v.merge(kafkaConfigPipe(), v.object({ type: v.is("kafka") })).pipe(({ type: _, ...config }) => new KafkaEventBus(config)),
-  rabbitmq: v.merge(rabbitmqConfigPipe(), v.object({ type: v.is("rabbitmq") })).pipe(({ type: _, ...config }) => new RabbitMQEventBus(config))
-});
-const dbPipe = () => v.object({
-  db: v.discriminate((e) => e?.type, {
-    mongo: v.merge(mongoDbConfigPipe(), v.object({ type: v.is("mongo") }))
-  }),
-  changes: v.optional(
-    v.object({
-      debeziumUrl: v.string(),
-      eventBus: v.instanceOf(KafkaEventBus)
-    })
-  )
-}).pipe((config) => new MongoDb(config.db, { changes: config.changes }));
-const serverTypePipe = () => serverConfigPipe().pipe((config) => config.type === "express" ? new ExpressServer(config) : new FastifyServer(config));
-export {
-  cachePipe,
-  dbPipe,
-  eventBusPipe,
-  instanceSettingsPipe,
-  jobsPipe,
-  serverTypePipe
-};

package/dist/types/jobs/pipes.js

@@ -1,12 +0,0 @@
-import { v } from "valleyed";
-import { redisConfigPipe } from "../cache/index.js";
-const redisJobsConfigPipe = () => v.meta(
-  v.object({
-    redisConfig: redisConfigPipe(),
-    queueName: v.string()
-  }),
-  { title: "Redis Jobs Config", $refId: "RedisJobsConfig" }
-);
-export {
-  redisJobsConfigPipe
-};