@unchainedshop/core-users 5.0.0-alpha.1 → 5.0.0-alpha.11

package/lib/infrastructure/persistence/MongoUserRepository.js

@@ -1,159 +0,0 @@
-import { generateDbFilterById, buildSortOptions, insensitiveTrimmedRegexOperator, } from '@unchainedshop/mongodb';
-import { SortDirection } from '@unchainedshop/utils';
-import { reconstituteUser } from "../../domain/model/User.js";
-import { buildUserSelector } from "./buildUserSelector.js";
-export const createMongoUserRepository = (collection, db) => {
-    const buildFindOptions = (options) => {
-        const findOptions = {};
-        if (options?.offset) {
-            findOptions.skip = options.offset;
-        }
-        if (options?.limit) {
-            findOptions.limit = options.limit;
-        }
-        if (options?.sort) {
-            findOptions.sort = buildSortOptions(options.sort);
-        }
-        return findOptions;
-    };
-    return {
-        async findById(id) {
-            if (!id)
-                return null;
-            const data = await collection.findOne(generateDbFilterById(id));
-            return data ? reconstituteUser(data) : null;
-        },
-        async findByUsername(username) {
-            if (!username)
-                return null;
-            const data = await collection.findOne({
-                username: insensitiveTrimmedRegexOperator(username),
-            });
-            return data ? reconstituteUser(data) : null;
-        },
-        async findByEmail(email) {
-            if (!email)
-                return null;
-            const data = await collection.findOne({
-                'emails.address': insensitiveTrimmedRegexOperator(email),
-            });
-            return data ? reconstituteUser(data) : null;
-        },
-        async findByToken(hashedToken) {
-            if (!hashedToken)
-                return null;
-            const data = await collection.findOne({
-                'services.token.secret': hashedToken,
-            });
-            return data ? reconstituteUser(data) : null;
-        },
-        async findOne(query, options) {
-            const selector = buildUserSelector(query);
-            const findOptions = buildFindOptions(options);
-            const data = await collection.findOne(selector, findOptions);
-            return data ? reconstituteUser(data) : null;
-        },
-        async findMany(query, options) {
-            const selector = buildUserSelector(query);
-            const defaultSort = [{ key: 'created', value: SortDirection.ASC }];
-            const findOptions = buildFindOptions(options);
-            if (query.queryString) {
-                const docs = await collection
-                    .find(selector, {
-                    ...findOptions,
-                    projection: { score: { $meta: 'textScore' } },
-                    sort: { score: { $meta: 'textScore' } },
-                })
-                    .toArray();
-                return docs.map(reconstituteUser);
-            }
-            if (!findOptions.sort) {
-                findOptions.sort = buildSortOptions(defaultSort);
-            }
-            const docs = await collection.find(selector, findOptions).toArray();
-            return docs.map(reconstituteUser);
-        },
-        async count(query) {
-            const selector = buildUserSelector(query);
-            return collection.countDocuments(selector);
-        },
-        async exists(userId) {
-            const count = await collection.countDocuments({ _id: userId, deleted: null }, { limit: 1 });
-            return count === 1;
-        },
-        async findByVerificationToken(hashedToken, validAfter) {
-            if (!hashedToken)
-                return null;
-            const data = await collection.findOne({
-                'services.email.verificationTokens': {
-                    $elemMatch: {
-                        token: hashedToken,
-                        when: { $gt: validAfter },
-                    },
-                },
-            });
-            if (!data)
-                return null;
-            const verificationToken = data.services?.email?.verificationTokens?.find((v) => v.token === hashedToken);
-            if (!verificationToken)
-                return null;
-            return {
-                userId: data._id,
-                address: verificationToken.address,
-                when: verificationToken.when,
-                token: verificationToken.token,
-            };
-        },
-        async findByResetToken(hashedToken, validAfter) {
-            if (!hashedToken)
-                return null;
-            const data = await collection.findOne({
-                'services.password.reset': {
-                    $elemMatch: {
-                        token: hashedToken,
-                        when: { $gt: validAfter },
-                    },
-                },
-            });
-            if (!data)
-                return null;
-            const passwordService = data.services?.password;
-            const resetToken = passwordService?.reset?.find((v) => v.token === hashedToken);
-            if (!resetToken)
-                return null;
-            return {
-                userId: data._id,
-                address: resetToken.address,
-                when: resetToken.when,
-                token: resetToken.token,
-            };
-        },
-        async save(user) {
-            const data = user.toData();
-            await collection.replaceOne({ _id: data._id }, data, { upsert: true });
-            user.clearChanges();
-        },
-        async insert(user) {
-            const data = user.toData();
-            await collection.insertOne(data);
-            user.clearChanges();
-            return data._id;
-        },
-        async delete(userId) {
-            const result = await collection.deleteOne({ _id: userId });
-            return result.deletedCount > 0;
-        },
-        async deleteUserSessions(userId) {
-            await db.collection('sessions').deleteMany({
-                session: insensitiveTrimmedRegexOperator(`"user":"${userId}"`),
-            });
-        },
-        async distinctTags() {
-            const tags = (await collection.distinct('tags', {
-                tags: { $exists: true },
-                deleted: null,
-            }));
-            return tags.filter(Boolean).sort();
-        },
-    };
-};

package/lib/infrastructure/persistence/buildUserSelector.d.ts

@@ -1,4 +0,0 @@
-import { type mongodb } from '@unchainedshop/mongodb';
-import type { UserQuery } from '../../domain/repository/UserRepository.ts';
-import type { UserData } from '../../domain/model/User.ts';
-export declare const buildUserSelector: ({ includeGuests, includeDeleted, queryString, emailVerified, lastLogin, tags, userIds, username, usernames, emails, web3Verified, }: UserQuery) => mongodb.Filter<UserData>;

package/lib/infrastructure/persistence/buildUserSelector.js

@@ -1,54 +0,0 @@
-import { insensitiveTrimmedRegexOperator, assertDocumentDBCompatMode, } from '@unchainedshop/mongodb';
-export const buildUserSelector = ({ includeGuests, includeDeleted, queryString, emailVerified, lastLogin, tags, userIds, username, usernames, emails, web3Verified, }) => {
-    const selector = {};
-    if (!includeDeleted) {
-        selector.deleted = null;
-    }
-    if (!includeGuests) {
-        selector.guest = { $ne: true };
-    }
-    if (userIds) {
-        selector._id = { $in: userIds };
-    }
-    if (username) {
-        selector.username = insensitiveTrimmedRegexOperator(username);
-    }
-    if (usernames?.length) {
-        selector.username = {
-            $in: usernames.map((u) => insensitiveTrimmedRegexOperator(u)),
-        };
-    }
-    if (emails?.length) {
-        selector['emails.address'] = {
-            $in: emails.map((e) => insensitiveTrimmedRegexOperator(e)),
-        };
-    }
-    if (emailVerified === true) {
-        selector['emails.verified'] = true;
-    }
-    if (emailVerified === false) {
-        selector['emails.verified'] = { $ne: true };
-    }
-    if (Array.isArray(tags) && tags.length) {
-        selector.tags = { $in: tags };
-    }
-    if (web3Verified === true) {
-        selector['services.web3.verified'] = true;
-    }
-    if (lastLogin?.start || lastLogin?.end) {
-        const timestampFilter = { $exists: true };
-        if (lastLogin.end) {
-            timestampFilter.$lte = typeof lastLogin.end === 'string' ? new Date(lastLogin.end) : lastLogin.end;
-        }
-        if (lastLogin.start) {
-            timestampFilter.$gte =
-                typeof lastLogin.start === 'string' ? new Date(lastLogin.start) : lastLogin.start;
-        }
-        selector['lastLogin.timestamp'] = timestampFilter;
-    }
-    if (queryString) {
-        assertDocumentDBCompatMode();
-        selector.$text = { $search: queryString };
-    }
-    return selector;
-};

package/lib/infrastructure/services/CryptoTokenService.d.ts

@@ -1,2 +0,0 @@
-import type { TokenService } from '../../domain/services/TokenService.ts';
-export declare const createCryptoTokenService: () => TokenService;

package/lib/infrastructure/services/CryptoTokenService.js

@@ -1,16 +0,0 @@
-import { sha256 } from '@unchainedshop/utils';
-export const createCryptoTokenService = () => {
-    return {
-        generateToken() {
-            return crypto.randomUUID();
-        },
-        async hashToken(plainToken) {
-            return sha256(plainToken);
-        },
-        async generateHashedToken() {
-            const plain = crypto.randomUUID();
-            const hashed = await sha256(plain);
-            return { plain, hashed };
-        },
-    };
-};

package/lib/infrastructure/services/Pbkdf2PasswordService.d.ts

@@ -1,2 +0,0 @@
-import type { PasswordService } from '../../domain/services/PasswordService.ts';
-export declare const createPbkdf2PasswordService: () => PasswordService;

package/lib/infrastructure/services/Pbkdf2PasswordService.js

@@ -1,23 +0,0 @@
-import * as bcrypt from 'bcryptjs';
-import { sha256 } from '@unchainedshop/utils';
-import * as pbkdf2 from "../../module/pbkdf2.js";
-export const createPbkdf2PasswordService = () => {
-    return {
-        async hash(plainPassword) {
-            const salt = pbkdf2.generateSalt();
-            const hashedPassword = await pbkdf2.getDerivedKey(salt, plainPassword);
-            return { pbkdf2: `${salt}:${hashedPassword}` };
-        },
-        async verify(hash, plainPassword) {
-            if (hash.pbkdf2) {
-                const [pbkdf2Salt, pbkdf2Hash] = hash.pbkdf2.split(':');
-                return pbkdf2.compare(plainPassword, pbkdf2Hash, pbkdf2Salt);
-            }
-            if (hash.bcrypt) {
-                const password = await sha256(plainPassword);
-                return bcrypt.compare(password, hash.bcrypt);
-            }
-            return false;
-        },
-    };
-};