@slango/mangusta 2.1.40 → 2.1.41

package/src/middleware/email.spec.ts

@@ -1,86 +0,0 @@
-import mongoose, { Document, model, Schema } from 'mongoose';
-import { describe, expect, it } from 'vitest';
-
-import { setupMongoTestEnvironment } from '../test-utils/mongooseTestEnvironment.js';
-import emailMiddleware from './email.js';
-
-setupMongoTestEnvironment();
-
-interface TestUser extends Document {
-  email: string;
-}
-
-const TestUserSchema = new Schema<TestUser>({});
-TestUserSchema.plugin(emailMiddleware);
-
-const TestUserModel = model<TestUser>('TestUser', TestUserSchema);
-
-const validEmail = 'valid.email@example.com';
-const invalidEmail = 'invalid-email';
-const customErrorMessage = 'Custom error message for invalid email';
-
-describe('emailMiddleware', () => {
-  it('should allow saving a user with a valid email', async () => {
-    const user = new TestUserModel({ email: validEmail });
-
-    await expect(user.save()).resolves.not.toThrow();
-  });
-
-  it('should fail when saving a user with an invalid email', async () => {
-    const user = new TestUserModel({ email: invalidEmail });
-
-    await expect(user.save()).rejects.toThrowError(mongoose.Error.ValidationError);
-  });
-
-  it('should enforce uniqueness for email', async () => {
-    await TestUserModel.init();
-
-    const user1 = new TestUserModel({ email: validEmail });
-    const user2 = new TestUserModel({ email: validEmail });
-
-    await user1.save();
-    await expect(user2.save()).rejects.toThrowError(Error);
-  });
-
-  it('should allow saving a user without an email if "required" is set to false', async () => {
-    const OptionalEmailUserSchema = new Schema<TestUser>({});
-    OptionalEmailUserSchema.plugin(emailMiddleware, { required: false });
-    const OptionalEmailUserModel = model<TestUser>('OptionalEmailUser', OptionalEmailUserSchema);
-
-    const user = new OptionalEmailUserModel({});
-
-    await expect(user.save()).resolves.not.toThrow();
-  });
-
-  it('should display custom error message for invalid email', async () => {
-    const CustomMessageSchema = new Schema<TestUser>({});
-    CustomMessageSchema.plugin(emailMiddleware, { doesNotMatchMessage: customErrorMessage });
-    const CustomMessageUserModel = model<TestUser>('CustomMessageUser', CustomMessageSchema);
-
-    const user = new CustomMessageUserModel({ email: invalidEmail });
-
-    await expect(user.save()).rejects.toThrowError(customErrorMessage);
-  });
-
-  it('should allow saving a user with a non-unique email if "unique" is set to false', async () => {
-    const NonUniqueEmailSchema = new Schema<TestUser>({});
-    NonUniqueEmailSchema.plugin(emailMiddleware, { unique: false });
-    const NonUniqueEmailUserModel = model<TestUser>('NonUniqueEmailUser', NonUniqueEmailSchema);
-
-    const user1 = new NonUniqueEmailUserModel({ email: validEmail });
-    const user2 = new NonUniqueEmailUserModel({ email: validEmail });
-
-    await expect(user1.save()).resolves.not.toThrow();
-    await expect(user2.save()).resolves.not.toThrow(); // Should pass without unique constraint
-  });
-
-  it('should trim email addresses before saving', async () => {
-    const user = new TestUserModel({ email: ` ${validEmail} ` });
-
-    await user.save();
-    const savedUser = await TestUserModel.findOne({ email: validEmail });
-
-    expect(savedUser).toBeDefined();
-    expect(savedUser?.email).toBe(validEmail);
-  });
-});

package/src/middleware/email.ts

@@ -1,49 +0,0 @@
-import { Document, Model, Schema } from 'mongoose';
-
-import { PluginFunction } from '../types.js';
-
-export const emailRegexp = /^[\w.%+-]+@[a-z0-9.-]+\.[a-z]{2,}$/i;
-
-export type WithEmail<
-  Field extends string = 'email',
-  Required extends boolean = true,
-> = Required extends true ? { [key in Field]: string } : { [key in Field]?: string };
-
-interface EmailMiddlewareOptions<Field extends string = 'email'> {
-  doesNotMatchMessage?: string;
-  field?: Field;
-  index?: boolean;
-  regExp?: RegExp;
-  required?: boolean;
-  unique?: boolean;
-}
-
-const emailMiddleware: PluginFunction<EmailMiddlewareOptions> = <
-  Field extends string = 'email',
-  DocType extends Document & WithEmail<Field> = Document & WithEmail<Field>,
->(
-  schema: Schema<DocType, Model<DocType>>,
-  {
-    doesNotMatchMessage,
-    field = 'email' as Field,
-    index = true,
-    regExp = emailRegexp,
-    required = true,
-    unique = true,
-  }: EmailMiddlewareOptions<Field> = {},
-): void => {
-  const emailSchema = new Schema<WithEmail<Field>>({
-    [field]: {
-      index,
-      match: doesNotMatchMessage ? [regExp, doesNotMatchMessage] : regExp,
-      required,
-      trim: true,
-      type: String,
-      unique,
-    },
-  });
-
-  schema.add(emailSchema);
-};
-
-export default emailMiddleware;

package/src/middleware/owner.spec.ts

@@ -1,77 +0,0 @@
-import mongoose, { Document, Types } from 'mongoose';
-import { describe, expect, it } from 'vitest';
-
-import { createModelWithPlugin } from '../test-utils/model.js';
-import { setupMongoTestEnvironment } from '../test-utils/mongooseTestEnvironment.js';
-import { PluginFunction } from '../types.js';
-import ownerMiddleware, { OwnerMiddlewareOptions, WithOwner } from './owner.js';
-
-setupMongoTestEnvironment();
-
-type TestDoc<Field extends string = 'user'> = Document<Types.ObjectId> &
-  WithOwner<Types.ObjectId, Field>;
-
-const createTestModel = <Field extends string = 'user'>(options?: OwnerMiddlewareOptions<Field>) =>
-  createModelWithPlugin<TestDoc<Field>, OwnerMiddlewareOptions<Field>>({
-    modelName: 'TestDoc',
-    plugin: ownerMiddleware as PluginFunction<OwnerMiddlewareOptions<Field>>,
-    pluginOptions: options,
-  });
-
-describe('ownerMiddleware', () => {
-  it('should add a "user" field by default with correct options', async () => {
-    const { model: TestModel } = createTestModel();
-    const doc = new TestModel({ user: new Types.ObjectId() });
-
-    await expect(doc.save()).resolves.not.toThrow();
-    const savedDoc = await TestModel.findOne({ _id: doc._id });
-    expect(savedDoc).toBeDefined();
-    expect(savedDoc?.user?.toString()).toBe(doc.user.toString());
-  });
-
-  it('should not allow saving without user field if required', async () => {
-    const { model: TestModel } = createTestModel();
-    const doc = new TestModel({});
-
-    await expect(doc.save()).rejects.toThrowError(mongoose.Error.ValidationError);
-  });
-
-  it('should allow configuring the field name', async () => {
-    const { model: TestModel } = createTestModel<'owner'>({ field: 'owner' });
-    const doc = new TestModel({ owner: new Types.ObjectId() });
-
-    await expect(doc.save()).resolves.not.toThrow();
-    const savedDoc = await TestModel.findOne({ _id: doc._id });
-
-    expect(savedDoc).toBeDefined();
-    expect(savedDoc?.owner?.toString()).toBe(doc.owner.toString());
-  });
-
-  it('should allow optional "user" field if "required" is set to false', async () => {
-    const { model: TestModel } = createTestModel({ required: false });
-    const doc = new TestModel({});
-
-    await expect(doc.save()).resolves.not.toThrow();
-    const savedDoc = await TestModel.findOne({ _id: doc._id });
-    expect(savedDoc).toBeDefined();
-    expect(savedDoc?.user).toBeUndefined();
-  });
-
-  it('should apply "index" option to the field', () => {
-    const { schema } = createTestModel({ index: true });
-    const indexes = schema.indexes();
-    const userIndex = indexes.find(([fields]) =>
-      Object.prototype.hasOwnProperty.call(fields, 'user'),
-    );
-
-    expect(userIndex).toBeDefined();
-    expect(userIndex![0].user).toBe(1);
-  });
-
-  it('should reference the specified model in "ref"', () => {
-    const { schema } = createTestModel({ ref: 'CustomUser' });
-    const refField = schema.path('user');
-
-    expect(refField.options.ref).toBe('CustomUser');
-  });
-});

package/src/middleware/owner.ts

@@ -1,39 +0,0 @@
-import { Document, Schema, Types } from 'mongoose';
-
-import { PluginFunction } from '../types.js';
-
-export interface OwnerMiddlewareOptions<Field extends string = 'user'> {
-  field?: Field;
-  index?: boolean;
-  ref?: string;
-  required?: boolean;
-}
-
-export type WithOwner<T = Types.ObjectId, Field extends string = 'user'> = {
-  [key in Field]: T;
-};
-
-const ownerMiddleware: PluginFunction<OwnerMiddlewareOptions> = <
-  Field extends string = 'user',
-  DocType extends Document & WithOwner<Field> = Document & WithOwner<Field>,
->(
-  schema: Schema<DocType>,
-  {
-    field = 'user' as Field,
-    index = true,
-    ref = 'User',
-    required = true,
-  }: OwnerMiddlewareOptions<Field> = {},
-): void => {
-  const fieldDescription = new Schema<WithOwner<Field>>({
-    [field]: {
-      index,
-      ref,
-      required,
-      type: Types.ObjectId,
-    },
-  });
-  schema.add(fieldDescription);
-};
-
-export default ownerMiddleware;

package/src/middleware/password.spec.ts

@@ -1,83 +0,0 @@
-import mongoose, { Document, model, Schema } from 'mongoose';
-import { describe, expect, it } from 'vitest';
-
-import type { PluginFunction } from '../types.js';
-
-import { setupMongoTestEnvironment } from '../test-utils/mongooseTestEnvironment.js';
-import passwordMiddleware, { PasswordMiddlewareOptions, WithPassword } from './password.js';
-
-setupMongoTestEnvironment();
-
-type TestDoc<
-  Field extends string = 'password',
-  ComparisonFunction extends string = 'comparePassword',
-> = Document & WithPassword<Field, ComparisonFunction>;
-
-const createTestModel = <
-  Field extends string = 'password',
-  ComparisonFunction extends string = 'comparePassword',
->(
-  options?: PasswordMiddlewareOptions<Field, ComparisonFunction>,
-) => {
-  const modelName = 'TestDoc';
-
-  if (mongoose.models[modelName]) {
-    delete mongoose.models[modelName];
-  }
-
-  const TestSchema = new Schema<TestDoc<Field, ComparisonFunction>>({});
-  if (options) {
-    TestSchema.plugin(
-      passwordMiddleware as PluginFunction<PasswordMiddlewareOptions<Field, ComparisonFunction>>,
-      options,
-    );
-  } else {
-    TestSchema.plugin(passwordMiddleware);
-  }
-
-  return model<TestDoc<Field, ComparisonFunction>>(modelName, TestSchema);
-};
-
-describe('passwordMiddleware', () => {
-  it('should hash password and provide comparison method', async () => {
-    const TestModel = createTestModel();
-    const plain = 'Valid@123';
-    const doc = new TestModel({ password: plain });
-
-    await expect(doc.save()).resolves.not.toThrow();
-    const saved = await TestModel.findById(doc._id);
-
-    expect(saved).toBeDefined();
-    expect(saved!.password).not.toBe(plain);
-    await expect(saved!.comparePassword(plain)).resolves.toBe(true);
-    await expect(saved!.comparePassword('Wrong@123')).resolves.toBe(false);
-  });
-
-  it('should reject invalid passwords', async () => {
-    const TestModel = createTestModel();
-    const doc = new TestModel({ password: 'invalid' });
-
-    await expect(doc.save()).rejects.toThrowError(mongoose.Error.ValidationError);
-  });
-
-  it('should allow configuring field and comparison function names', async () => {
-    const TestModel = createTestModel<'pass', 'checkPassword'>({
-      field: 'pass',
-      comparisonFunction: 'checkPassword',
-    });
-    const doc = new TestModel({ pass: 'Valid@123' });
-
-    await expect(doc.save()).resolves.not.toThrow();
-    const saved = await TestModel.findById(doc._id);
-
-    expect(saved).toBeDefined();
-    await expect(saved!.checkPassword('Valid@123')).resolves.toBe(true);
-  });
-
-  it('should allow optional password field when required is false', async () => {
-    const TestModel = createTestModel({ required: false });
-    const doc = new TestModel({});
-
-    await expect(doc.save()).resolves.not.toThrow();
-  });
-});

package/src/middleware/password.ts

@@ -1,77 +0,0 @@
-import { compare, hash } from 'bcrypt';
-import { Document, Model, Schema } from 'mongoose';
-
-import { PluginFunction } from '../types.js';
-
-export type WithPassword<
-  Field extends string = 'password',
-  ComparisonFunction extends string = 'comparePassword',
-> = {
-  [key in ComparisonFunction]: (password: string) => Promise<boolean>;
-} & {
-  [key in Field]: string;
-};
-
-export const passwordRegExp = /^(?=.*\d)(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&*)(\][+=.,_-]).{8,}$/;
-
-export interface PasswordMiddlewareOptions<
-  Field extends string = 'password',
-  ComparisonFunction extends string = 'comparePassword',
-> {
-  comparisonFunction?: ComparisonFunction;
-  doesNotMatchMessage?: string;
-  field?: Field;
-  regExp?: RegExp;
-  required?: boolean;
-  saltingRounds?: number;
-}
-
-const passwordMiddleware: PluginFunction<PasswordMiddlewareOptions> = <
-  Field extends string = 'password',
-  ComparisonFunction extends string = 'comparePassword',
-  DocType extends Document & WithPassword<Field, ComparisonFunction> = Document &
-    WithPassword<Field, ComparisonFunction>,
->(
-  schema: Schema<DocType, Model<DocType>>,
-  {
-    comparisonFunction = 'comparePassword' as ComparisonFunction,
-    doesNotMatchMessage,
-    field = 'password' as Field,
-    regExp = passwordRegExp,
-    required = true,
-    saltingRounds = 10,
-  }: PasswordMiddlewareOptions<Field, ComparisonFunction> = {},
-): void => {
-  const fieldDescription = new Schema<WithPassword<Field, ComparisonFunction>>({
-    [field]: {
-      match: doesNotMatchMessage ? [regExp, doesNotMatchMessage] : regExp,
-      required,
-      type: String,
-    },
-  });
-
-  schema.add(fieldDescription);
-
-  schema.pre<DocType>('save', async function schemaWithPasswordPreSave(this: DocType) {
-    // only hash the password if it has been modified (or is new)
-    if (!this.isModified(field)) {
-      return;
-    }
-
-    // generate a hash and override the clear text password with the hashed one
-    this.set(field, await hash(this.get(field) as DocType[Field], saltingRounds));
-  });
-
-  schema.methods[comparisonFunction] = async function comparePassword(
-    this: DocType & Document,
-    candidate: string,
-  ): Promise<boolean> {
-    try {
-      return await compare(candidate, this.get(field) as DocType[Field]);
-    } catch {
-      return false;
-    }
-  };
-};
-
-export default passwordMiddleware;

package/src/middleware/reactions.spec.ts

@@ -1,200 +0,0 @@
-import { Document, Schema, Types } from 'mongoose';
-import { describe, expect, it } from 'vitest';
-
-import type { PluginFunction } from '../types.js';
-
-import { createModelWithPlugin } from '../test-utils/model.js';
-import { setupMongoTestEnvironment } from '../test-utils/mongooseTestEnvironment.js';
-import reactionsMiddleware, {
-  defaultReactionTypes,
-  ReactionCountSummary,
-  ReactionsMiddlewareOptions,
-  WithReactions,
-  WithReactionsMethods,
-} from './reactions.js';
-
-setupMongoTestEnvironment();
-
-type TestDoc<
-  Field extends string = 'reactions',
-  UserField extends string = 'user',
-  TypeField extends string = 'type',
-  TimestampField extends string = 'createdAt',
-> = Document &
-  WithReactions<Field, UserField, TypeField, TimestampField> &
-  WithReactionsMethods & {
-    [key: string]: unknown;
-  };
-
-const createTestModel = <
-  Field extends string = 'reactions',
-  UserField extends string = 'user',
-  TypeField extends string = 'type',
-  TimestampField extends string = 'createdAt',
->(
-  options?: ReactionsMiddlewareOptions<Field, UserField, TypeField, TimestampField>,
-) =>
-  createModelWithPlugin<
-    TestDoc<Field, UserField, TypeField, TimestampField>,
-    ReactionsMiddlewareOptions<Field, UserField, TypeField, TimestampField>
-  >({
-    modelName: 'ReactionsTestDoc',
-    plugin: reactionsMiddleware as PluginFunction<
-      ReactionsMiddlewareOptions<Field, UserField, TypeField, TimestampField>
-    >,
-    pluginOptions: options,
-    buildSchema: () => new Schema<TestDoc<Field, UserField, TypeField, TimestampField>>({}),
-  });
-
-describe('reactionsMiddleware', () => {
-  it('should add reactions field and persist entries with defaults', async () => {
-    const { model: TestModel } = createTestModel();
-    const userId = new Types.ObjectId();
-
-    const doc = new TestModel();
-    doc.reactions.push({ user: userId, type: defaultReactionTypes[0] });
-
-    await expect(doc.save()).resolves.not.toThrow();
-
-    const saved = await TestModel.findById(doc._id);
-    expect(saved).toBeDefined();
-    expect(saved!.reactions).toHaveLength(1);
-    expect(saved!.reactions[0]?.user?.toString()).toBe(userId.toString());
-    expect(saved!.reactions[0]?.type).toBe(defaultReactionTypes[0]);
-    expect(saved!.reactions[0]?.createdAt).toBeInstanceOf(Date);
-  });
-
-  it('should deduplicate reactions for the same user when multiple reactions are disabled', async () => {
-    const { model: TestModel } = createTestModel();
-    const userId = new Types.ObjectId();
-
-    const doc = new TestModel({
-      reactions: [
-        { user: userId, type: '👍' },
-        { user: userId, type: '❤️' },
-      ],
-    });
-
-    await expect(doc.save()).resolves.not.toThrow();
-
-    const saved = await TestModel.findById(doc._id).lean();
-    expect(saved).toBeDefined();
-    expect(saved!.reactions).toHaveLength(1);
-    expect(saved!.reactions[0]?.type).toBe('❤️');
-  });
-
-  it('should allow multiple reactions for the same user when enabled', async () => {
-    const { model: TestModel } = createTestModel({ allowMultiplePerUser: true });
-    const userId = new Types.ObjectId();
-
-    const doc = new TestModel();
-    doc.addReaction(userId, '👍');
-    doc.addReaction(userId, '❤️');
-
-    await expect(doc.save()).resolves.not.toThrow();
-
-    const saved = await TestModel.findById(doc._id);
-    expect(saved?.reactions).toHaveLength(2);
-    const types = saved?.reactions.map((reaction) => reaction.type).sort();
-    expect(types).toEqual(['❤️', '👍']);
-  });
-
-  it('should expose helper methods for managing reactions', async () => {
-    const { model: TestModel } = createTestModel();
-    const userId = new Types.ObjectId();
-
-    const doc = new TestModel();
-    doc.addReaction(userId, '👍');
-    doc.addReaction(userId, '❤️');
-
-    expect(doc.hasReaction(userId, '❤️')).toBe(true);
-    expect(doc.hasReaction(userId, '👍')).toBe(false);
-
-    const summary = doc.countReactions() as ReactionCountSummary;
-    expect(summary.total).toBe(1);
-    expect(summary.perType['❤️']).toBe(1);
-
-    const heartCount = doc.countReactions('❤️');
-    expect(heartCount).toBe(1);
-
-    doc.removeReaction(userId, '❤️');
-    expect(doc.hasReaction(userId)).toBe(false);
-
-    await expect(doc.save()).resolves.not.toThrow();
-    const saved = await TestModel.findById(doc._id);
-    expect(saved?.reactions).toHaveLength(0);
-  });
-
-  it('should reject unsupported reaction types', async () => {
-    const { model: TestModel } = createTestModel();
-    const userId = new Types.ObjectId();
-    const doc = new TestModel();
-
-    expect(() => doc.addReaction(userId, 'unsupported')).toThrowError(
-      /Reaction type "unsupported" is not permitted/,
-    );
-
-    doc.reactions.push({ user: userId, type: 'unsupported' });
-    await expect(doc.save()).rejects.toThrowError(
-      /`unsupported` is not a valid enum value for path `type`/,
-    );
-  });
-
-  it('should allow custom configuration for field and helper schema options', async () => {
-    const { model: TestModel, schema } = createTestModel<'feedback', 'member', 'category', 'time'>({
-      field: 'feedback',
-      userField: 'member',
-      typeField: 'category',
-      timestampField: 'time',
-      allowMultiplePerUser: true,
-      allowedTypes: ['👏', '😲'],
-      indexUser: false,
-      indexType: true,
-      timestamp: true,
-      userRef: 'Account',
-    });
-
-    const doc = new TestModel();
-    const memberId = new Types.ObjectId();
-
-    doc.addReaction(memberId, '👏');
-    doc.addReaction(memberId, '😲');
-
-    expect(doc.hasReaction(memberId, '😲')).toBe(true);
-    const stats = doc.countReactions() as ReactionCountSummary;
-    expect(stats.total).toBe(2);
-    expect(Object.keys(stats.perType).sort()).toEqual(['👏', '😲']);
-
-    await expect(doc.save()).resolves.not.toThrow();
-
-    const indexes = schema.indexes();
-    const categoryIndex = indexes.find(([fields]) =>
-      Object.prototype.hasOwnProperty.call(fields, 'feedback.category'),
-    );
-    const memberIndex = indexes.find(([fields]) =>
-      Object.prototype.hasOwnProperty.call(fields, 'feedback.member'),
-    );
-
-    expect(categoryIndex).toBeDefined();
-    expect(memberIndex).toBeUndefined();
-
-    const saved = await TestModel.findById(doc._id).lean();
-    expect(saved?.feedback).toHaveLength(2);
-    expect(saved?.feedback[0]).toHaveProperty('time');
-    expect(saved?.feedback[1]).toHaveProperty('time');
-  });
-
-  it('should support disabling timestamps', async () => {
-    const { model: TestModel } = createTestModel({ timestamp: false });
-    const userId = new Types.ObjectId();
-
-    const doc = new TestModel();
-    doc.addReaction(userId, '👍');
-
-    await expect(doc.save()).resolves.not.toThrow();
-
-    const saved = await TestModel.findById(doc._id).lean();
-    expect(saved?.reactions).toHaveLength(1);
-    expect(saved?.reactions[0]?.createdAt).toBeUndefined();
-  });
-});