assai 0.4.2 → 0.4.3

package/dist/index.d.mts

@@ -0,0 +1,2 @@
+export * from "./src/factories/index.mjs";
+export * from "./src/usecases/index.mjs";

package/dist/src/data/errors/operation_fail.d.mts

@@ -0,0 +1,7 @@
+export class OperationFail extends Error {
+    /**
+     *
+     * @param {string} msg
+     */
+    constructor(msg: string);
+}

package/dist/src/factories/create_mongo_collection.d.mts

@@ -0,0 +1,95 @@
+/**
+ * Generates a collection object that automatically manage ObjectId conversion to string.
+ *
+ * This method will read the string DATABASE_URL to create a connection. If you have it in another
+ * location, you will need to pass it at `connectionString` property inside the options parameter.
+ *
+ * The connection is cached by default. Use `collectionGetter` and `cachedCollectionGetter` to
+ * customize this behavior.
+ * @template {import('../types.js').MongoDocument} T
+ * @param {string} name
+ * @param {IcreateCollectionOptions<T>} [options]
+ */
+export function createMongoCollection<T extends import("../types.js").MongoDocument>(name: string, options?: IcreateCollectionOptions<T> | undefined): Promise<{
+    /**
+     * Returns the native driver.
+     */
+    getCollection: () => Promise<Collection<T>>;
+    /**
+     * @param {import('mongodb').Filter<T>} query
+     */
+    count: (query?: import("mongodb").Filter<T>) => Promise<number>;
+    /**
+     * @template {import('../types.js').Projection<T>} K
+     * @param {import('mongodb').Filter<T>} query
+     * @param {import('../types.js').FindOptions<T, K>} options
+     * @returns {Promise<T[]>}
+     */
+    find: <K extends import("../types.js").Projection<T>>(query: import("mongodb").Filter<T>, options?: import("../types.js").FindOptions<T, K>) => Promise<T[]>;
+    /**
+     * @template {import('../types.js').Projection<T> | undefined} K
+     * @param {import('mongodb').Filter<T>} query
+     * @param {import('../types.js').FindOptions<T,K>} options
+     * @returns {Promise<T | null>}
+     */
+    findOne: <K_1 extends import("../types.js").Projection<T>>(query: import("mongodb").Filter<T>, options?: import("../types.js").FindOptions<T, K_1>) => Promise<T | null>;
+    /**
+     * @param {import('../types.js').Optional<T, 'id'>} doc
+     * @returns {Promise<T>}
+     */
+    insertOne: (doc: import("../types.js").Optional<T, "id">) => Promise<T>;
+    /**
+     *
+     * @param {import('../types.js').Optional<T, 'id'>[]} docs
+     * @returns {Promise<T[]>}
+     */
+    insertMany: (docs: import("../types.js").Optional<T, "id">[]) => Promise<T[]>;
+    /**
+     * @param {import('mongodb').Filter<T>} query
+     * @returns {Promise<boolean>}
+     */
+    deleteOne: (query: import("mongodb").Filter<T>) => Promise<boolean>;
+    /**
+     * Deletes the first document to match the query.
+     * This method will throw an error if no documents were deleted.
+     * @param {import('mongodb').Filter<T>} query
+     * @throw {@link OperationFail} If not document was deleted
+     */
+    deleteOneOrThrow: (query: import("mongodb").Filter<T>) => Promise<void>;
+    /**
+     *
+     * @param {import('mongodb').Filter<T>} query
+     */
+    deleteMany: (query: import("mongodb").Filter<T>) => Promise<boolean>;
+    /**
+     * @param {import('mongodb').Filter<T>} query
+     * @param {import('mongodb').UpdateFilter<T>} update
+     */
+    updateOne: (query: import("mongodb").Filter<T>, update: import("mongodb").UpdateFilter<T>) => Promise<boolean>;
+    /**
+     * @param {import('mongodb').Filter<T>} query
+     * @param {import('mongodb').UpdateFilter<T>} update
+     */
+    updateMany: (query: import("mongodb").Filter<T>, update: import("mongodb").UpdateFilter<T>) => Promise<boolean>;
+}>;
+export type IcollectionGetter<T extends import("../types.js").MongoDocument> = () => Promise<Collection<T>>;
+export type IcreateCollectionOptions<T extends import("../types.js").MongoDocument> = {
+    /**
+     * A custom function to get the collection object from mongodb driver.
+     *
+     * This will be not be cached and will be used on every operation such as insertOne or findOne.
+     *
+     * If you wish to cache the collection object, see `cachableCollectionGetter`.
+     */
+    collectionGetter?: IcollectionGetter<T> | undefined;
+    /**
+     * Same as `collectionGetter`. But the object is cached.
+     */
+    cachableCollectionGetter?: IcollectionGetter<T> | undefined;
+    /**
+     * A custom connection string. If none is given, `process.env.DATABASE_URL` will be used.
+     */
+    connectionString?: string | undefined;
+};
+export type ICollection<T extends import("../types.js").MongoDocument> = Awaited<ReturnType<typeof createMongoCollection<T>>>;
+import { Collection } from 'mongodb';

package/dist/src/factories/index.d.mts

@@ -0,0 +1 @@
+export * from "./create_mongo_collection.mjs";

package/dist/src/types.d.ts

@@ -0,0 +1,21 @@
+import { FindOptions as FO } from 'mongodb';
+export type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+export type MongoDocument = {
+    id: string;
+    [key: string]: any;
+};
+export type RequiredIfPresent<T, U> = {
+    [P in keyof T]: P extends keyof U ? Required<T[P]> : T[P];
+};
+type NonNullProjection<T extends MongoDocument> = Partial<Record<keyof T, 1 | 0>>;
+export type Projection<T extends MongoDocument> = NonNullProjection<T> | undefined;
+type GivenProjectionReturnType<T extends MongoDocument, P extends NonNullProjection<T>> = P extends Partial<Record<keyof T, 0>> ? {
+    [K in keyof T as P[K] extends 0 ? never : K]: T[K];
+} : {
+    [K in keyof T as P[K] extends 1 ? K : never]: T[K];
+};
+export type ProjectionReturnType<T extends MongoDocument, P extends Projection<T>> = P extends NonNullProjection<T> ? GivenProjectionReturnType<T, P> : T;
+export type FindOptions<T extends MongoDocument, K extends Projection<T>> = Omit<FO<T>, 'projection'> & {
+    projection?: K;
+};
+export {};

package/dist/src/usecases/index.d.mts

@@ -0,0 +1 @@
+export * as mongo from "./mongo/index.mjs";

package/dist/src/usecases/mongo/generate_new_id.d.mts

@@ -0,0 +1 @@
+export function generateNewId(): string;

package/dist/src/usecases/mongo/index.d.mts

@@ -0,0 +1,3 @@
+export * from "./generate_new_id.mjs";
+export * from "./mongo_client.mjs";
+export * from "./operation/index.mjs";

package/dist/src/usecases/mongo/mongo_client.d.mts

@@ -0,0 +1,10 @@
+/**
+ *
+ * @param {object} params
+ * @param {string} [params.connectionString]
+ */
+export function getClient({ connectionString, }?: {
+    connectionString?: string | undefined;
+}): Promise<MongoClient>;
+export function closeClient(): Promise<void>;
+import { MongoClient } from 'mongodb';

package/dist/src/usecases/mongo/operation/additional/delete_one_or_throw.d.mts

@@ -0,0 +1,11 @@
+/**
+ * @template {import('../../../../types.js').MongoDocument} T
+ * @param {object} param
+ * @param {import('mongodb').Filter<T>} param.query
+ * @param {() => Promise<Collection<T>>} param.getCollection
+ */
+export function deleteOneOrThrow<T extends import("../../../../types.js").MongoDocument>({ query, getCollection, }: {
+    query: import("mongodb").Filter<T>;
+    getCollection: () => Promise<Collection<T>>;
+}): Promise<void>;
+import { Collection } from 'mongodb';

package/dist/src/usecases/mongo/operation/additional/index.d.mts

@@ -0,0 +1 @@
+export * from "./delete_one_or_throw.mjs";

package/dist/src/usecases/mongo/operation/count.d.mts

@@ -0,0 +1,11 @@
+/**
+ * @template {import('../../../types.js').MongoDocument} T
+ * @param {object} params
+ * @param {() => Promise<Collection<T>>} params.getCollection
+ * @param {import('mongodb').Filter<T>} [params.query]
+ */
+export function count<T extends import("../../../types.js").MongoDocument>({ getCollection, query }: {
+    getCollection: () => Promise<Collection<T>>;
+    query?: import("mongodb").Filter<T> | undefined;
+}): Promise<number>;
+import { Collection } from 'mongodb';

package/dist/src/usecases/mongo/operation/delete_many.d.mts

@@ -0,0 +1,11 @@
+/**
+ * @template {import('../../../types.js').MongoDocument} T
+ * @param {object} parameter
+ * @param {import('mongodb').Filter<T>} parameter.query
+ * @param {() => Promise<Collection<T>>} parameter.getCollection
+ */
+export function deleteMany<T extends import("../../../types.js").MongoDocument>({ query, getCollection }: {
+    query: import("mongodb").Filter<T>;
+    getCollection: () => Promise<Collection<T>>;
+}): Promise<boolean>;
+import { Collection } from 'mongodb';

package/dist/src/usecases/mongo/operation/delete_one.d.mts

@@ -0,0 +1,12 @@
+/**
+ * @template {import('../../../types.js').MongoDocument} T
+ * @param {object} parameter
+ * @param {import('mongodb').Filter<T>} parameter.query
+ * @param {() => Promise<Collection<T>>} parameter.getCollection
+ * @returns {Promise<boolean>}
+ */
+export function deleteOne<T extends import("../../../types.js").MongoDocument>({ query, getCollection }: {
+    query: import("mongodb").Filter<T>;
+    getCollection: () => Promise<Collection<T>>;
+}): Promise<boolean>;
+import { Collection } from 'mongodb';

package/dist/src/usecases/mongo/operation/find.d.mts

@@ -0,0 +1,15 @@
+/**
+ * @template {import('../../../types.js').MongoDocument} T
+ * @template {import('../../../types.js').Projection<T>} K
+ * @param {object} parameter
+ * @param {() => Promise<Collection<T>>} parameter.getCollection
+ * @param {import('mongodb').Filter<T>} parameter.query
+ * @param {import('../../../types.js').FindOptions<T, K>} [parameter.options]
+ * @returns {Promise<T[]>}
+ */
+export function find<T extends import("../../../types.js").MongoDocument, K extends import("../../../types.js").Projection<T>>({ getCollection, query, options }: {
+    getCollection: () => Promise<Collection<T>>;
+    query: import("mongodb").Filter<T>;
+    options?: import("../../../types.js").FindOptions<T, K> | undefined;
+}): Promise<T[]>;
+import { Collection } from 'mongodb';

package/dist/src/usecases/mongo/operation/find_one.d.mts

@@ -0,0 +1,14 @@
+/**
+ * @template {import('../../../types.js').MongoDocument} T
+ * @template {import('../../../types.js').Projection<T> | undefined} K
+ * @param {object} param
+ * @param {import('mongodb').Filter<T>} param.query
+ * @param {import('../../../types.js').FindOptions<T, K>} [param.options]
+ * @param {() => Promise<Collection<T>>} param.getCollection
+ */
+export function findOne<T extends import("../../../types.js").MongoDocument, K extends import("../../../types.js").Projection<T>>({ query, options, getCollection }: {
+    query: import("mongodb").Filter<T>;
+    options?: import("../../../types.js").FindOptions<T, K> | undefined;
+    getCollection: () => Promise<Collection<T>>;
+}): Promise<T | null>;
+import { Collection } from 'mongodb';

package/dist/src/usecases/mongo/operation/index.d.mts

@@ -0,0 +1,10 @@
+export * from "./additional/index.mjs";
+export * from "./count.mjs";
+export * from "./delete_many.mjs";
+export * from "./delete_one.mjs";
+export * from "./find.mjs";
+export * from "./find_one.mjs";
+export * from "./insert_many.mjs";
+export * from "./insert_one.mjs";
+export * from "./update_many.mjs";
+export * from "./update_one.mjs";

package/dist/src/usecases/mongo/operation/insert_many.d.mts

@@ -0,0 +1,12 @@
+/**
+ * @template {import('../../../types.js').MongoDocument} T
+ * @param {object} param
+ * @param {import('../../../types.js').Optional<T, 'id'>[]} param.docs
+ * @param {() => Promise<Collection<T>>} param.getCollection
+ * @returns {Promise<T[]>}
+ */
+export function insertMany<T extends import("../../../types.js").MongoDocument>({ docs, getCollection }: {
+    docs: import("../../../types.js").Optional<T, "id">[];
+    getCollection: () => Promise<Collection<T>>;
+}): Promise<T[]>;
+import { Collection } from 'mongodb';

package/dist/src/usecases/mongo/operation/insert_one.d.mts

@@ -0,0 +1,12 @@
+/**
+ * @template {import('../../../types.js').MongoDocument} T
+ * @param {object} param
+ * @param {import('../../../types.js').Optional<T, 'id'>} param.doc
+ * @param {() => Promise<Collection<T>>} param.getCollection
+ * @returns {Promise<T>}
+ */
+export function insertOne<T extends import("../../../types.js").MongoDocument>({ doc, getCollection }: {
+    doc: import("../../../types.js").Optional<T, "id">;
+    getCollection: () => Promise<Collection<T>>;
+}): Promise<T>;
+import { Collection } from 'mongodb';

package/dist/src/usecases/mongo/operation/update_many.d.mts

@@ -0,0 +1,13 @@
+/**
+ * @template {import('../../../types.js').MongoDocument} T
+ * @param {object} param
+ * @param {import('mongodb').Filter<T>} param.query
+ * @param {import('mongodb').UpdateFilter<T>} param.update
+ * @param {() => Promise<Collection<T>>} param.getCollection
+ */
+export function updateMany<T extends import("../../../types.js").MongoDocument>({ query, update, getCollection }: {
+    query: import("mongodb").Filter<T>;
+    update: import("mongodb").UpdateFilter<T>;
+    getCollection: () => Promise<Collection<T>>;
+}): Promise<boolean>;
+import { Collection } from 'mongodb';

package/dist/src/usecases/mongo/operation/update_one.d.mts

@@ -0,0 +1,13 @@
+/**
+ * @template {import('../../../types.js').MongoDocument} T
+ * @param {object} param
+ * @param {import('mongodb').Filter<T>} param.query
+ * @param {import('mongodb').UpdateFilter<T>} param.update
+ * @param {() => Promise<Collection<T>>} param.getCollection
+ */
+export function updateOne<T extends import("../../../types.js").MongoDocument>({ query, update, getCollection }: {
+    query: import("mongodb").Filter<T>;
+    update: import("mongodb").UpdateFilter<T>;
+    getCollection: () => Promise<Collection<T>>;
+}): Promise<boolean>;
+import { Collection } from 'mongodb';

package/dist/src/usecases/mongo/test/manage_mock_registry.d.mts

@@ -0,0 +1,12 @@
+/**
+ *
+ * @param {import('./mock_get_collection.mjs').ItestCollection} param
+ * @param {object} options
+ * @param {boolean} [options.deleteAtEnd]
+ */
+export function manageMockRegistry({ tag, ...rest }?: import('./mock_get_collection.mjs').ItestCollection, { deleteAtEnd }?: {
+    deleteAtEnd?: boolean | undefined;
+}): {
+    id: string;
+    name: string;
+};

package/dist/src/usecases/mongo/test/mock_get_collection.d.mts

@@ -0,0 +1,12 @@
+export function mockGetCollection(collectionName?: string): Promise<Collection<ItestCollection>>;
+export type ItestCollection = {
+    _id?: ObjectId | undefined;
+    id?: string | undefined;
+    name?: string | undefined;
+    tag?: string | ObjectId | undefined;
+    createdAt?: Date | undefined;
+    posts?: any[] | undefined;
+    address?: object;
+};
+import { Collection } from 'mongodb';
+import { ObjectId } from 'mongodb';

package/dist/src/usecases/mongo/transformers/id/index.d.mts

@@ -0,0 +1,3 @@
+export * from "./rename_find_options.mjs";
+export * from "./rename_to_dev_id.mjs";
+export * from "./rename_to_mongo_id.mjs";

package/dist/src/usecases/mongo/transformers/id/rename_find_options.d.mts

@@ -0,0 +1,5 @@
+/**
+ *
+ * @param {import('../../../../types.js').FindOptions<any ,any>} options
+ */
+export function renameFindOptions(options?: import('../../../../types.js').FindOptions<any, any>): void;

package/dist/src/usecases/mongo/transformers/id/rename_to_dev_id.d.mts

@@ -0,0 +1,6 @@
+/**
+ * ```
+ * "_id" -> "id"
+ * ```
+ */
+export function renameToDevId(obj: any): any;

package/dist/src/usecases/mongo/transformers/id/rename_to_mongo_id.d.mts

@@ -0,0 +1,6 @@
+/**
+ * ```
+ * "id" -> "_id"
+ * ```
+ */
+export function renameToMongoId(obj: any): any;

package/dist/src/usecases/mongo/transformers/index.d.mts

@@ -0,0 +1,2 @@
+export * from "./id/index.mjs";
+export * from "./object_id/index.mjs";

package/dist/src/usecases/mongo/transformers/object_id/ids_into_strings.d.mts

@@ -0,0 +1,7 @@
+/**
+ * Convert the parameter from `ObjectId` into string whenever possible.
+ *
+ * If an object or array is given, this function will be applied recursively.
+ * @param {*} obj
+ */
+export function idsIntoString(obj: any): any;

package/dist/src/usecases/mongo/transformers/object_id/index.d.mts

@@ -0,0 +1,2 @@
+export * from "./ids_into_strings.mjs";
+export * from "./strings_into_id.mjs";

package/dist/src/usecases/mongo/transformers/object_id/strings_into_id.d.mts

@@ -0,0 +1,11 @@
+/**
+ * Converts the input value into an `ObjectId`, doing a recursive internal search if possible.
+ *
+ * This function will do a recursive operation if the parameter is any of the following:
+ * - An object;
+ * - An array;
+ *
+ * If the parameter is a string, then it is converted to `ObjectId` if possible.
+ * @param {*} obj
+ */
+export function stringsIntoId(obj: any): any;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "assai",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "repository": {
     "url": "https://github.com/TimeLord2010/assai",
     "type": "git"
@@ -9,7 +9,7 @@
   "main": "index.mjs",
   "types": "dist/index.d.mts",
   "scripts": {
-    "postinstall": "tsc -p ./jsconfig.prod.json",
+    "prepare": "tsc -p ./jsconfig.prod.json",
     "start": "node --env-file=.env index.mjs",
     "test": "node --env-file=.env --test"
   },
@@ -20,6 +20,7 @@
   "files": [
     "index.mjs",
     "src/",
+    "dist",
     "!src/**/*.test.mjs",
     "jsconfig.json",
     "jsconfig.prod.json"