equipped 5.2.9 → 5.3.0-alpha.0

package/dist/{esm/events/types/kafka.mjs → types/chunk-IAHTILKJ.js}

@@ -1,18 +1,60 @@
+import {
+  EquippedError,
+  Instance,
+  configurable,
+  parseJSONValue,
+  random_exports
+} from "./chunk-32DMHN3G.js";
+import {
+  EventBus
+} from "./chunk-KZKFYO4V.js";
+
+// src/events/adapters/kafka/index.ts
 import { KafkaJS } from "@confluentinc/kafka-javascript";
-import { EquippedError } from "../../errors/index.mjs";
-import { Instance } from "../../instance/index.mjs";
-import { Random, parseJSONValue } from "../../utilities/index.mjs";
-import { EventBus } from "../base.mjs";
-class KafkaEventBus extends EventBus {
+import { v } from "valleyed";
+var 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" }
+);
+var KafkaEventBus = class _KafkaEventBus extends configurable(kafkaConfigPipe, EventBus) {
   #client;
-  #admin;
+  #admin = null;
   constructor(config) {
-    super();
+    super(config);
     this.#client = new KafkaJS.Kafka({
       kafkaJS: { ...config, logLevel: KafkaJS.logLevel.NOTHING }
     });
   }
-  createStream(topicName, options = {}) {
+  async #getAdmin() {
+    if (!this.#admin)
+      this.#admin = (async () => {
+        const admin = this.#client.admin();
+        await admin.connect();
+        return admin;
+      })();
+    return this.#admin;
+  }
+  async #createTopic(topic) {
+    const admin = await this.#getAdmin();
+    await admin.createTopics({ topics: [{ topic }], timeout: 5e3 });
+  }
+  async #deleteGroup(groupId) {
+    const admin = await this.#getAdmin();
+    await admin.deleteGroups([groupId]).catch(() => {
+    });
+  }
+  stream(topicName, options = {}) {
     const topic = options.skipScope ? topicName : Instance.get().getScopedName(topicName);
     return {
       publish: async (data) => {
@@ -27,7 +69,7 @@ class KafkaEventBus extends EventBus {
       subscribe: (onMessage) => {
         const subscribe = async () => {
           await this.#createTopic(topic);
-          const groupId = options.fanout ? Instance.get().getScopedName(`${Instance.get().id}-fanout-${Random.string(10)}`) : topic;
+          const groupId = options.fanout ? Instance.get().getScopedName(`${Instance.get().id}-fanout-${random_exports.string(10)}`) : topic;
           const consumer = this.#client.consumer({ kafkaJS: { groupId } });
           await consumer.connect();
           await consumer.subscribe({ topic });
@@ -42,39 +84,18 @@ class KafkaEventBus extends EventBus {
             }
           });
           if (options.fanout)
-            Instance.on(
-              "close",
-              async () => {
-                await consumer.disconnect();
-                await this.#deleteGroup(groupId);
-              },
-              10
-            );
+            Instance.on("close", async () => {
+              await consumer.disconnect();
+              await this.#deleteGroup(groupId);
+            }, { class: _KafkaEventBus });
         };
-        Instance.on("start", subscribe, 2);
+        Instance.on("start", subscribe, { class: _KafkaEventBus });
       }
     };
   }
-  async #getAdmin() {
-    if (!this.#admin)
-      this.#admin = (async () => {
-        const admin = this.#client.admin();
-        await admin.connect();
-        return admin;
-      })();
-    return this.#admin;
-  }
-  async #createTopic(topic) {
-    const admin = await this.#getAdmin();
-    await admin.createTopics({ topics: [{ topic }], timeout: 5e3 });
-  }
-  async #deleteGroup(groupId) {
-    const admin = await this.#getAdmin();
-    await admin.deleteGroups([groupId]).catch(() => {
-    });
-  }
-}
+};
+
 export {
+  kafkaConfigPipe,
   KafkaEventBus
 };
-//# sourceMappingURL=kafka.mjs.map

package/dist/types/chunk-JZ2JTENY.js

@@ -0,0 +1,125 @@
+import {
+  KafkaEventBus
+} from "./chunk-IAHTILKJ.js";
+import {
+  Instance
+} from "./chunk-32DMHN3G.js";
+
+// src/dbs/adapters/base/db.ts
+var Db = class {
+  constructor(config) {
+    this.config = config;
+  }
+  getScopedDb(db) {
+    return Instance.get().getScopedName(db).replaceAll(".", "-");
+  }
+};
+
+// src/dbs/adapters/base/types.ts
+import { v } from "valleyed";
+var dbChangeConfigPipe = () => v.object({
+  debeziumUrl: v.string(),
+  eventBus: v.instanceOf(KafkaEventBus)
+});
+
+// src/dbs/pipes.ts
+import { v as v2 } from "valleyed";
+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";
+  return Conditions2;
+})(Conditions || {});
+var queryKeys = v2.catch(v2.defaults(v2.in(["and" /* and */, "or" /* or */]), "and" /* and */), "and" /* and */);
+var queryWhere = v2.object({
+  field: v2.string(),
+  value: v2.any(),
+  // eslint-disable-next-line promise/valid-params -- valleyed v.catch(schema, fallback) is not Promise.prototype.catch
+  condition: v2.catch(v2.defaults(v2.in(Object.values(Conditions)), "eq" /* eq */), "eq" /* eq */)
+});
+var queryWhereBlock = v2.recursive(
+  () => v2.discriminate((d) => Object.values(QueryKeys).includes(d.condition) ? "block" : "regular", {
+    block: v2.object({
+      condition: queryKeys,
+      value: v2.array(queryWhereBlock)
+    }),
+    regular: queryWhere
+  }),
+  "QueryWhereBlock"
+);
+var queryWhereClause = v2.defaults(v2.array(queryWhereBlock), []);
+function queryParamsPipe() {
+  return v2.meta(
+    v2.object({
+      all: v2.defaults(v2.boolean(), false),
+      limit: v2.lazy(() => {
+        const pagLimit = Instance.get().settings.utils.paginationDefaultLimit;
+        return v2.catch(v2.defaults(v2.number().pipe(v2.lte(pagLimit)), pagLimit), pagLimit);
+      }),
+      // eslint-disable-next-line promise/valid-params -- valleyed v.catch(schema, fallback) is not Promise.prototype.catch
+      page: v2.catch(v2.defaults(v2.number().pipe(v2.gte(1)), 1), 1),
+      search: v2.defaults(
+        v2.nullish(
+          v2.object({
+            value: v2.string(),
+            fields: v2.array(v2.string())
+          })
+        ),
+        null
+      ),
+      sort: v2.defaults(
+        v2.array(
+          v2.object({
+            field: v2.string(),
+            desc: v2.defaults(v2.boolean(), false)
+          })
+        ),
+        []
+      ),
+      whereType: queryKeys,
+      where: queryWhereClause,
+      select: v2.optional(v2.array(v2.string()))
+    }).pipe((p) => ({ ...p, auth: [], authType: "and" /* and */ })),
+    { title: "Query Params", $refId: "QueryParams" }
+  );
+}
+function queryResultsPipe(model) {
+  return v2.object({
+    pages: v2.object({
+      current: v2.number(),
+      start: v2.number(),
+      last: v2.number(),
+      previous: v2.nullable(v2.number()),
+      next: v2.nullable(v2.number())
+    }),
+    docs: v2.object({
+      limit: v2.number(),
+      total: v2.number(),
+      count: v2.number()
+    }),
+    results: v2.array(model)
+  });
+}
+function wrapQueryParams(params) {
+  return v2.assert(queryParamsPipe(), params);
+}
+
+export {
+  Db,
+  dbChangeConfigPipe,
+  QueryKeys,
+  Conditions,
+  queryParamsPipe,
+  queryResultsPipe,
+  wrapQueryParams
+};

package/dist/types/chunk-KZKFYO4V.js

@@ -0,0 +1,7 @@
+// src/events/adapters/base.ts
+var EventBus = class {
+};
+
+export {
+  EventBus
+};

package/dist/types/chunk-LN3A6R4Y.js

@@ -0,0 +1,28 @@
+// src/jobs/adapters/base.ts
+var JobNames = /* @__PURE__ */ ((JobNames2) => {
+  JobNames2["CronJob"] = "CronJob";
+  JobNames2["RepeatableJob"] = "RepeatableJob";
+  JobNames2["DelayedJob"] = "DelayedJob";
+  return JobNames2;
+})(JobNames || {});
+var Job = class {
+  #crons = [];
+  #callbacks = {};
+  get callbacks() {
+    return this.#callbacks;
+  }
+  set callbacks(newCallbacks) {
+    this.#callbacks = newCallbacks;
+  }
+  get crons() {
+    return this.#crons;
+  }
+  set crons(newCrons) {
+    this.#crons = newCrons;
+  }
+};
+
+export {
+  JobNames,
+  Job
+};

package/dist/types/chunk-LWUMIHL4.js

@@ -0,0 +1,21 @@
+import {
+  Instance
+} from "./chunk-32DMHN3G.js";
+
+// src/cache/adapters/base.ts
+var Cache = class {
+  getScopedKey(key) {
+    return Instance.get().getScopedName(key, ":");
+  }
+  async getOrSet(key, fn, ttlInSecs) {
+    const cached = await this.get(key);
+    if (cached) return JSON.parse(cached);
+    const result = await fn();
+    await this.set(key, JSON.stringify(result), ttlInSecs);
+    return result;
+  }
+};
+
+export {
+  Cache
+};

package/dist/types/chunk-MLKGABMK.js

@@ -0,0 +1,9 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};

package/dist/types/chunk-XOU2A2Y6.js

@@ -0,0 +1,52 @@
+import {
+  EquippedError
+} from "./chunk-32DMHN3G.js";
+
+// src/orm/errors/introspection.ts
+var OrmIntrospectionError = class extends EquippedError {
+  adapter;
+  table;
+  constructor(opts) {
+    super(`Introspection failed for table '${opts.table}' on adapter '${opts.adapter}'`, { adapter: opts.adapter, table: opts.table }, opts.cause);
+    this.adapter = opts.adapter;
+    this.table = opts.table;
+  }
+};
+if (void 0) {
+  const { describe, test, expect } = void 0;
+  const { EquippedError: EquippedError2 } = await null;
+  describe("OrmIntrospectionError", () => {
+    test("stores adapter, table, and cause on the instance", () => {
+      const cause = new Error("unknown column type");
+      const err = new OrmIntrospectionError({ adapter: "postgres", table: "users", cause });
+      expect(err.adapter).toBe("postgres");
+      expect(err.table).toBe("users");
+      expect(err.cause).toBe(cause);
+    });
+    test("message includes adapter and table", () => {
+      const err = new OrmIntrospectionError({ adapter: "pg", table: "posts", cause: "bad type" });
+      expect(err.message).toBe("Introspection failed for table 'posts' on adapter 'pg'");
+    });
+    test("instanceof EquippedError is true", () => {
+      const err = new OrmIntrospectionError({ adapter: "x", table: "y", cause: null });
+      expect(err).toBeInstanceOf(OrmIntrospectionError);
+      expect(err).toBeInstanceOf(EquippedError2);
+    });
+    test("context carries adapter and table", () => {
+      const err = new OrmIntrospectionError({ adapter: "mem", table: "items", cause: "fail" });
+      expect(err.context.adapter).toBe("mem");
+      expect(err.context.table).toBe("items");
+    });
+    test("discriminates from sibling error classes", async () => {
+      const { OrmMigrationError } = await null;
+      const { OrmValidationError } = await null;
+      const err = new OrmIntrospectionError({ adapter: "x", table: "y", cause: null });
+      expect(err).not.toBeInstanceOf(OrmMigrationError);
+      expect(err).not.toBeInstanceOf(OrmValidationError);
+    });
+  });
+}
+
+export {
+  OrmIntrospectionError
+};

package/dist/types/{core-BrkNSwvc.d.ts → core-tNlIMH9Y.d.ts}

@@ -1,6 +1,27 @@
 import { Filter, UpdateFilter } from 'mongodb';
+import * as valleyed from 'valleyed';
 import { PipeOutput, Pipe, PipeInput, ConditionalObjectKeys, DistributiveOmit, DeepPartial } from 'valleyed';
-import { K as KafkaEventBus } from './kafka-Cf-TUJgv.js';
+import { KafkaEventBus } from './events/adapters/kafka/index.js';
+
+declare const dbChangeConfigPipe: () => valleyed.Pipe<{
+    debeziumUrl: string;
+    eventBus: KafkaEventBus;
+}, {
+    debeziumUrl: string;
+    eventBus: KafkaEventBus;
+}>;
+type DbChangeConfig = PipeOutput<ReturnType<typeof dbChangeConfigPipe>>;
+type DbConfig = {
+    changes?: DbChangeConfig;
+};
+
+declare abstract class DbChange<Model extends Model<IdType>, Entity extends Entity> {
+    protected config: DbChangeConfig;
+    protected callbacks: DbChangeCallbacks<Model, Entity>;
+    protected mapper: (model: Model) => Entity;
+    constructor(config: DbChangeConfig, callbacks: DbChangeCallbacks<Model, Entity>, mapper: (model: Model) => Entity);
+    protected configureConnector(key: string, data: Record<string, string>): Promise<any>;
+}
 
 declare enum QueryKeys {
     and = "and",
@@ -14,8 +35,7 @@ declare enum Conditions {
     eq = "eq",
     ne = "ne",
     in = "in",
-    nin = "nin",
-    exists = "exists"
+    nin = "nin"
 }
 declare const queryKeys: Pipe<QueryKeys | undefined, QueryKeys>;
 declare const queryWhere: Pipe<{
@@ -48,6 +68,7 @@ declare function queryParamsPipe(): Pipe<{
         condition: PipeInput<typeof queryKeys>;
         value: PipeInput<typeof queryWhere>[];
     })[] | undefined;
+    select: string[] | undefined;
 }, {
     auth: ({
         field: string;
@@ -78,6 +99,7 @@ declare function queryParamsPipe(): Pipe<{
         condition: PipeOutput<typeof queryKeys>;
         value: PipeOutput<typeof queryWhere>[];
     })[];
+    select: string[] | undefined;
 }>;
 declare function queryResultsPipe<T>(model: Pipe<any, T>): Pipe<{
     pages: {
@@ -108,10 +130,13 @@ declare function queryResultsPipe<T>(model: Pipe<any, T>): Pipe<{
     };
     results: T[];
 }>;
-declare function wrapQueryParams(params: QueryParamsInput): QueryParams;
-type QueryParams = PipeOutput<ReturnType<typeof queryParamsPipe>>;
+declare function wrapQueryParams(params: QueryParamsInput): QueryParamsBase;
+type QueryParamsBase = PipeOutput<ReturnType<typeof queryParamsPipe>>;
+type QueryParams<T, S extends Select<T> | undefined = undefined> = Omit<QueryParamsBase, 'select'> & {
+    select?: S extends undefined ? QueryParamsBase['select'] : S;
+};
 type QueryParamsInput = ConditionalObjectKeys<PipeInput<ReturnType<typeof queryParamsPipe>>>;
-type QueryWhereClause = QueryParams['where'][number];
+type QueryWhereClause = QueryParamsBase['where'][number];
 type QueryWhere = Extract<QueryWhereClause, {
     field: string;
 }>;
@@ -119,28 +144,6 @@ type QueryWhereBlock = Exclude<QueryWhereClause, {
     field: string;
 }>;
 type QueryResults<T> = PipeOutput<ReturnType<typeof queryResultsPipe<T>>>;
-declare const mongoDbConfigPipe: () => Pipe<{
-    uri: string;
-}, {
-    uri: string;
-}>;
-type MongoDbConfig = PipeOutput<ReturnType<typeof mongoDbConfigPipe>>;
-
-type DbChangeConfig = {
-    eventBus: KafkaEventBus;
-    debeziumUrl: string;
-};
-type DbConfig = {
-    changes?: DbChangeConfig;
-};
-
-declare abstract class DbChange<Model extends Model<IdType>, Entity extends Entity> {
-    protected config: DbChangeConfig;
-    protected callbacks: DbChangeCallbacks<Model, Entity>;
-    protected mapper: (model: Model) => Entity;
-    constructor(config: DbChangeConfig, callbacks: DbChangeCallbacks<Model, Entity>, mapper: (model: Model) => Entity);
-    protected configureConnector(key: string, data: Record<string, string>): Promise<any>;
-}
 
 type IdType = {
     _id: string;
@@ -155,15 +158,22 @@ type Model<IdKey extends IdType> = IdKey & {
     createdAt?: number;
     updatedAt?: number;
 };
-type Sort = NonNullable<QueryParams['sort']>[number];
+type Select<T> = (keyof T)[];
+type SelectEntity<E, S> = S extends readonly (keyof E)[] ? (S[number] extends never ? E : Pick<E, S[number]>) : E;
+type Sort = NonNullable<QueryParamsBase['sort']>[number];
+type FindManyOptions<T, S extends Select<T> | undefined = undefined> = {
+    limit?: number;
+    sort?: Sort | Sort[];
+    select?: S;
+};
+type FindOneOptions<T, S extends Select<T> | undefined = undefined> = {
+    select?: S;
+};
 type Table<Id extends IdType, T extends Model<Id>, E extends Entity, Extras extends Record<string, unknown> = {}> = {
-    query: (query: QueryParams) => Promise<QueryResults<E>>;
-    findMany: (filter: Filter<T>, options?: {
-        limit?: number;
-        sort?: Sort | Sort[];
-    }) => Promise<E[]>;
-    findOne: (filter: Filter<T>) => Promise<E | null>;
-    findById: (id: ModelId<T>) => Promise<E | null>;
+    query: <const S extends Select<T> | undefined = undefined>(query: QueryParams<T, S>) => Promise<QueryResults<SelectEntity<E, S>>>;
+    findMany: <const S extends Select<T> | undefined = undefined>(filter: Filter<T>, options?: FindManyOptions<T, S>) => Promise<SelectEntity<E, S>[]>;
+    findOne: <const S extends Select<T> | undefined = undefined>(filter: Filter<T>, options?: FindOneOptions<T, S>) => Promise<SelectEntity<E, S> | null>;
+    findById: <const S extends Select<T> | undefined = undefined>(id: ModelId<T>, options?: FindOneOptions<T, S>) => Promise<SelectEntity<E, S> | null>;
     insertOne: (values: CreateInput<T>, options?: {
         makeId?: () => string;
         getTime?: () => Date;
@@ -244,10 +254,10 @@ type DbChangeCallbacks<M extends Model<IdType>, E extends Entity> = {
 type Config<M extends Model<IdType>, E extends Entity> = {
     db: string;
     col: string;
-    mapper: (model: M) => E;
+    mapper: (model: M, select?: Select<E>) => E;
     options?: {
         skipAudit?: boolean;
     };
 };
 
-export { type BulkWriteOperation as B, type CreateInput as C, DbChange as D, type Entity as E, type IdType as I, type Model as M, QueryKeys as Q, type Table as T, type UpdateInput as U, type MongoDbConfig as a, type DbChangeConfig as b, type DbChangeCallbacks as c, type EntityInput as d, type Config as e, type DbConfig as f, Conditions as g, queryResultsPipe as h, type QueryParams as i, type QueryParamsInput as j, type QueryWhereClause as k, type QueryWhere as l, type QueryWhereBlock as m, type QueryResults as n, mongoDbConfigPipe as o, queryParamsPipe as q, wrapQueryParams as w };
+export { type BulkWriteOperation as B, type Config as C, DbChange as D, type Entity as E, type IdType as I, type Model as M, QueryKeys as Q, type Select as S, type Table as T, type UpdateInput as U, type DbChangeConfig as a, type DbChangeCallbacks as b, type DbConfig as c, type EntityInput as d, type CreateInput as e, dbChangeConfigPipe as f, Conditions as g, queryResultsPipe as h, type QueryParamsBase as i, type QueryParams as j, type QueryParamsInput as k, type QueryWhereClause as l, type QueryWhere as m, type QueryWhereBlock as n, type QueryResults as o, queryParamsPipe as q, wrapQueryParams as w };

package/dist/types/dbs/adapters/mongodb/index.d.ts

@@ -0,0 +1,43 @@
+import { Collection, MongoClient, ObjectId } from 'mongodb';
+import * as valleyed from 'valleyed';
+import { PipeInput } from 'valleyed';
+import { M as Model, E as Entity, D as DbChange, a as DbChangeConfig, b as DbChangeCallbacks, c as DbConfig, C as Config, T as Table } from '../../../core-tNlIMH9Y.js';
+import { Db } from '../../index.js';
+import '../../../events/adapters/kafka/index.js';
+import '../../../overrides-6Hxg764S.js';
+import '../../../events/index.js';
+
+declare const mongoDbConfigPipe: () => valleyed.Pipe<{
+    uri: string;
+}, {
+    uri: string;
+}>;
+type MongoDbConfig = PipeInput<ReturnType<typeof mongoDbConfigPipe>>;
+
+declare class MongoDbChange<Model extends Model<{
+    _id: string;
+}>, Entity extends Entity> extends DbChange<Model, Entity> {
+    #private;
+    constructor(config: MongoDbConfig, change: DbChangeConfig, collection: Collection<Model>, callbacks: DbChangeCallbacks<Model, Entity>, mapper: (model: Model) => Entity);
+}
+
+type IdType = {
+    _id: string;
+};
+declare class MongoDb extends Db<{
+    _id: string;
+}> {
+    #private;
+    private mongoConfig;
+    client: MongoClient;
+    constructor(mongoConfig: MongoDbConfig, dbConfig: DbConfig);
+    session<T>(callback: () => Promise<T>): Promise<T>;
+    id(): ObjectId;
+    use<Model extends Model<{
+        _id: string;
+    }>, Entity extends Entity>(config: Config<Model, Entity>): Table<IdType, Model, Entity, {
+        collection: Collection<Model>;
+    }>;
+}
+
+export { MongoDb, MongoDbChange, type MongoDbConfig, mongoDbConfigPipe };