@slango/mangusta 1.1.8 → 2.0.1

package/src/middleware/reactions.spec.ts

@@ -1,9 +1,10 @@
 import { setupMongoTestEnvironment } from '@slango.configs/vitest/helpers/mongooseTestEnvironment';
-import mongoose, { Document, model, Schema, Types } from 'mongoose';
+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 reactionsMiddleware, {
   defaultReactionTypes,
   ReactionCountSummary,
@@ -32,32 +33,22 @@ const createTestModel = <
   TimestampField extends string = 'createdAt',
 >(
   options?: ReactionsMiddlewareOptions<Field, UserField, TypeField, TimestampField>,
-) => {
-  const modelName = 'ReactionsTestDoc';
-
-  if (mongoose.models[modelName]) {
-    delete mongoose.models[modelName];
-  }
-
-  const TestSchema = new Schema<TestDoc<Field, UserField, TypeField, TimestampField>>({});
-
-  if (options) {
-    TestSchema.plugin(
-      reactionsMiddleware as PluginFunction<
-        ReactionsMiddlewareOptions<Field, UserField, TypeField, TimestampField>
-      >,
-      options,
-    );
-  } else {
-    TestSchema.plugin(reactionsMiddleware);
-  }
-
-  return model<TestDoc<Field, UserField, TypeField, TimestampField>>(modelName, TestSchema);
-};
+) =>
+  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 TestModel = createTestModel();
+    const { model: TestModel } = createTestModel();
     const userId = new Types.ObjectId();
 
     const doc = new TestModel();
@@ -74,7 +65,7 @@ describe('reactionsMiddleware', () => {
   });
 
   it('should deduplicate reactions for the same user when multiple reactions are disabled', async () => {
-    const TestModel = createTestModel();
+    const { model: TestModel } = createTestModel();
     const userId = new Types.ObjectId();
 
     const doc = new TestModel({
@@ -93,7 +84,7 @@ describe('reactionsMiddleware', () => {
   });
 
   it('should allow multiple reactions for the same user when enabled', async () => {
-    const TestModel = createTestModel({ allowMultiplePerUser: true });
+    const { model: TestModel } = createTestModel({ allowMultiplePerUser: true });
     const userId = new Types.ObjectId();
 
     const doc = new TestModel();
@@ -109,7 +100,7 @@ describe('reactionsMiddleware', () => {
   });
 
   it('should expose helper methods for managing reactions', async () => {
-    const TestModel = createTestModel();
+    const { model: TestModel } = createTestModel();
     const userId = new Types.ObjectId();
 
     const doc = new TestModel();
@@ -135,7 +126,7 @@ describe('reactionsMiddleware', () => {
   });
 
   it('should reject unsupported reaction types', async () => {
-    const TestModel = createTestModel();
+    const { model: TestModel } = createTestModel();
     const userId = new Types.ObjectId();
     const doc = new TestModel();
 
@@ -150,7 +141,7 @@ describe('reactionsMiddleware', () => {
   });
 
   it('should allow custom configuration for field and helper schema options', async () => {
-    const TestModel = createTestModel<'feedback', 'member', 'category', 'time'>({
+    const { model: TestModel, schema } = createTestModel<'feedback', 'member', 'category', 'time'>({
       field: 'feedback',
       userField: 'member',
       typeField: 'category',
@@ -176,7 +167,7 @@ describe('reactionsMiddleware', () => {
 
     await expect(doc.save()).resolves.not.toThrow();
 
-    const indexes = TestModel.schema.indexes();
+    const indexes = schema.indexes();
     const categoryIndex = indexes.find(([fields]) =>
       Object.prototype.hasOwnProperty.call(fields, 'feedback.category'),
     );
@@ -194,7 +185,7 @@ describe('reactionsMiddleware', () => {
   });
 
   it('should support disabling timestamps', async () => {
-    const TestModel = createTestModel({ timestamp: false });
+    const { model: TestModel } = createTestModel({ timestamp: false });
     const userId = new Types.ObjectId();
 
     const doc = new TestModel();

package/src/middleware/reactions.ts

@@ -185,55 +185,43 @@ const reactionsMiddleware: PluginFunction<ReactionsMiddlewareOptions> = <
     return normalized;
   };
 
-  schema.pre<DocType>('save', function reactionsPreSave(next) {
-    try {
-      const existing =
-        (this.get(field) as ReactionEntry<UserField, TypeField, TimestampField>[] | undefined) ??
-        [];
-
-      if (!existing.length) {
-        return next();
+  schema.pre<DocType>('save', function reactionsPreSave(this: DocType) {
+    const existing =
+      (this.get(field) as ReactionEntry<UserField, TypeField, TimestampField>[] | undefined) ?? [];
+
+    if (!existing.length) {
+      return;
+    }
+
+    const normalizedEntries: ReactionEntry<UserField, TypeField, TimestampField>[] = [];
+    const seenUsers = new Map<string, number>();
+    let modified = false;
+
+    for (const entry of existing) {
+      const normalized = normalizeEntry(entry);
+      if (!normalized) {
+        modified = true;
+        continue;
       }
 
-      const normalizedEntries: ReactionEntry<UserField, TypeField, TimestampField>[] = [];
-      const seenUsers = new Map<string, number>();
-      let modified = false;
+      if (!allowMultiplePerUser) {
+        const userKey = normalized[userField].toString();
+        const idx = seenUsers.get(userKey);
 
-      for (const entry of existing) {
-        const normalized = normalizeEntry(entry);
-        if (!normalized) {
+        if (idx !== undefined) {
+          normalizedEntries[idx] = normalized;
           modified = true;
-          continue;
-        }
-
-        if (!allowMultiplePerUser) {
-          const userKey = normalized[userField].toString();
-          const idx = seenUsers.get(userKey);
-
-          if (idx !== undefined) {
-            normalizedEntries[idx] = normalized;
-            modified = true;
-          } else {
-            seenUsers.set(userKey, normalizedEntries.length);
-            normalizedEntries.push(normalized);
-          }
         } else {
+          seenUsers.set(userKey, normalizedEntries.length);
           normalizedEntries.push(normalized);
         }
+      } else {
+        normalizedEntries.push(normalized);
       }
+    }
 
-      if (normalizedEntries.length !== existing.length || modified) {
-        this.set(field, normalizedEntries);
-      }
-
-      next();
-    } catch (err) {
-      if (err instanceof Error) {
-        next(err);
-        return;
-      }
-
-      next(new Error('Unknown error while normalizing reactions.'));
+    if (normalizedEntries.length !== existing.length || modified) {
+      this.set(field, normalizedEntries);
     }
   });
 

package/src/middleware/tags.spec.ts

@@ -1,33 +1,25 @@
 import { setupMongoTestEnvironment } from '@slango.configs/vitest/helpers/mongooseTestEnvironment';
-import mongoose, { Document, model, Schema } from 'mongoose';
+import mongoose, { Document } from 'mongoose';
 import { describe, expect, it } from 'vitest';
 
+import { createModelWithPlugin } from '../test-utils/model.js';
+import { PluginFunction } from '../types.js';
 import tagsMiddleware, { TagsMiddlewareOptions, WithTags } from './tags.js';
 
 setupMongoTestEnvironment();
 
 type TestDoc<Field extends string = 'tags'> = Document & WithTags<Field>;
 
-const createTestModel = <Field extends string = 'tags'>(options?: TagsMiddlewareOptions<Field>) => {
-  const modelName = 'TestDoc';
-
-  if (mongoose.models[modelName]) {
-    delete mongoose.models[modelName];
-  }
-
-  const TestSchema = new Schema<TestDoc<Field>>({});
-  if (options) {
-    TestSchema.plugin(tagsMiddleware, options as TagsMiddlewareOptions);
-  } else {
-    TestSchema.plugin(tagsMiddleware);
-  }
-
-  return model<TestDoc<Field>>(modelName, TestSchema);
-};
+const createTestModel = <Field extends string = 'tags'>(options?: TagsMiddlewareOptions<Field>) =>
+  createModelWithPlugin<TestDoc<Field>, TagsMiddlewareOptions<Field>>({
+    modelName: 'TestDoc',
+    plugin: tagsMiddleware as PluginFunction<TagsMiddlewareOptions<Field>>,
+    pluginOptions: options,
+  });
 
 describe('tagsMiddleware', () => {
   it('should add a "tags" field with correct content if tags are provided', async () => {
-    const TestModel = createTestModel();
+    const { model: TestModel } = createTestModel();
     const doc = new TestModel({ tags: ['tag1', 'tag2'] });
 
     await expect(doc.save()).resolves.not.toThrow();
@@ -38,7 +30,7 @@ describe('tagsMiddleware', () => {
   });
 
   it('should add a "tags" field with empty array if no tag is provided', async () => {
-    const TestModel = createTestModel();
+    const { model: TestModel } = createTestModel();
     const doc = new TestModel({});
 
     await expect(doc.save()).resolves.not.toThrow();
@@ -49,7 +41,7 @@ describe('tagsMiddleware', () => {
   });
 
   it('should ensure uniqueness of tags if "unique" is set to true', async () => {
-    const TestModel = createTestModel({ unique: true });
+    const { model: TestModel } = createTestModel({ unique: true });
     const doc = new TestModel({ tags: ['tag1', 'tag2', 'tag1'] });
 
     await expect(doc.save()).resolves.not.toThrow();
@@ -60,7 +52,7 @@ describe('tagsMiddleware', () => {
   });
 
   it('should not enforce uniqueness if "unique" is set to false', async () => {
-    const TestModel = createTestModel({ unique: false });
+    const { model: TestModel } = createTestModel({ unique: false });
     const doc = new TestModel({ tags: ['tag1', 'tag2', 'tag1'] });
 
     await expect(doc.save()).resolves.not.toThrow();
@@ -71,7 +63,7 @@ describe('tagsMiddleware', () => {
   });
 
   it('should validate tags with custom validation function', async () => {
-    const TestModel = createTestModel({
+    const { model: TestModel } = createTestModel({
       validate: (tags) => tags.every((tag) => tag.startsWith('valid')),
     });
 
@@ -83,7 +75,7 @@ describe('tagsMiddleware', () => {
   });
 
   it('should allow configuring the field name', async () => {
-    const TestModel = createTestModel<'customTags'>({ field: 'customTags' });
+    const { model: TestModel } = createTestModel<'customTags'>({ field: 'customTags' });
     const doc = new TestModel({ customTags: ['tag1', 'tag2'] });
 
     await expect(doc.save()).resolves.not.toThrow();
@@ -94,16 +86,16 @@ describe('tagsMiddleware', () => {
   });
 
   it('should add a text index when index is set to "text"', () => {
-    const TestModel = createTestModel({ index: 'text' });
-    const indexes = TestModel.schema.indexes();
+    const { schema } = createTestModel({ index: 'text' });
+    const indexes = schema.indexes();
 
     const textIndex = indexes.find(([fields]) => fields.tags === 'text');
     expect(textIndex).toBeDefined();
   });
 
   it('should add a hashed index when index is set to "hashed"', () => {
-    const TestModel = createTestModel({ index: 'hashed' });
-    const indexes = TestModel.schema.indexes();
+    const { schema } = createTestModel({ index: 'hashed' });
+    const indexes = schema.indexes();
 
     const textIndex = indexes.find(([fields]) => fields.tags === 'hashed');
     expect(textIndex).toBeDefined();

package/src/middleware/tags.ts

@@ -43,13 +43,11 @@ const tagsMiddleware: PluginFunction<TagsMiddlewareOptions> = <
     schema.index({ [field]: index });
   }
 
-  schema.pre<DocType>('save', function schemaWithTagsPreSave(next) {
+  schema.pre<DocType>('save', function schemaWithTagsPreSave(this: DocType) {
     const tags = this.get(field) as DocType[Field];
     if (unique && tags) {
       this.set(field, Array.from(new Set(tags)));
     }
-
-    next();
   });
 };
 

package/src/middleware/timestamps.spec.ts

@@ -1,37 +1,25 @@
 import { setupMongoTestEnvironment } from '@slango.configs/vitest/helpers/mongooseTestEnvironment';
-import mongoose, { Document, model, Schema } from 'mongoose';
+import { Document } from 'mongoose';
 import { setTimeout as delay } from 'node:timers/promises';
 import { describe, expect, it } from 'vitest';
 
+import { createModelWithPlugin } from '../test-utils/model.js';
 import timestampsMiddleware, { TimestampsMiddlewareOptions, WithTimestamps } from './timestamps.js';
 
 setupMongoTestEnvironment();
 
 type TestDoc = Document & WithTimestamps & { name: string };
 
-const createTestModel = (options?: TimestampsMiddlewareOptions) => {
-  const modelName = 'TestDoc';
-
-  if (mongoose.models[modelName]) {
-    delete mongoose.models[modelName];
-  }
-
-  const TestSchema = new Schema<TestDoc>({
-    name: String,
+const createTestModel = (options?: TimestampsMiddlewareOptions) =>
+  createModelWithPlugin<TestDoc, TimestampsMiddlewareOptions>({
+    modelName: 'TestDoc',
+    plugin: timestampsMiddleware,
+    pluginOptions: options,
   });
 
-  if (options) {
-    TestSchema.plugin(timestampsMiddleware, options);
-  } else {
-    TestSchema.plugin(timestampsMiddleware);
-  }
-
-  return model<TestDoc>(modelName, TestSchema);
-};
-
 describe('timestampsMiddleware', () => {
   it('should store creation and update timestamps correctly on save', async () => {
-    const TestModel = createTestModel();
+    const { model: TestModel } = createTestModel();
     const doc = new TestModel({ name: 'initial' });
 
     await expect(doc.save()).resolves.not.toThrow();
@@ -56,7 +44,7 @@ describe('timestampsMiddleware', () => {
   });
 
   it('should update timestamp when using updateOne operations', async () => {
-    const TestModel = createTestModel();
+    const { model: TestModel } = createTestModel();
     const doc = new TestModel({ name: 'initial' });
     await doc.save();
 
@@ -72,8 +60,8 @@ describe('timestampsMiddleware', () => {
   });
 
   it('should add an index on the update field when indexUpdate is true', () => {
-    const TestModel = createTestModel({ indexUpdate: true });
-    const indexes = TestModel.schema.indexes();
+    const { schema } = createTestModel({ indexUpdate: true });
+    const indexes = schema.indexes();
 
     const index = indexes.find(([fields]) => fields.updated === 1);
     expect(index).toBeDefined();

package/src/middleware/timestamps.ts

@@ -54,29 +54,21 @@ const timestampsMiddleware: PluginFunction<TimestampsMiddlewareOptions> = <
     );
   }
 
-  schema.pre('save', function schemaWithTimestampsPreSave(next) {
-    try {
-      const now = new Date();
+  schema.pre<DocType>('save', function schemaWithTimestampsPreSave(this: DocType) {
+    const now = new Date();
 
-      if (creation && this.isNew && !this.get(creationField)) {
-        this.set(creationField, now);
-      }
+    if (creation && this.isNew && !this.get(creationField)) {
+      this.set(creationField, now);
+    }
 
-      if (update) {
-        if (this.isNew) {
-          if (updateTimestampOnCreation) {
-            this.set(updateField, now);
-          }
-          // else: do nothing so it's undefined
-        } else {
+    if (update) {
+      if (this.isNew) {
+        if (updateTimestampOnCreation) {
           this.set(updateField, now);
         }
-      }
-
-      next();
-    } catch (err) {
-      if (err instanceof Error) {
-        next(err);
+        // else: do nothing so it's undefined
+      } else {
+        this.set(updateField, now);
       }
     }
   });

package/src/test-utils/model.ts

@@ -0,0 +1,29 @@
+import mongoose, { Document, Model, Schema } from 'mongoose';
+
+import { PluginFunction } from '../types.js';
+
+export interface CreateModelWithPluginParams<Doc extends Document, Options> {
+  buildSchema?: () => Schema<Doc>;
+  modelName: string;
+  plugin: PluginFunction<Options>;
+  pluginOptions?: Options;
+}
+
+export const createModelWithPlugin = <Doc extends Document, Options>({
+  buildSchema,
+  modelName,
+  plugin,
+  pluginOptions,
+}: CreateModelWithPluginParams<Doc, Options>): { model: Model<Doc>; schema: Schema<Doc> } => {
+  if (mongoose.models[modelName]) {
+    delete mongoose.models[modelName];
+  }
+
+  const schema = buildSchema ? buildSchema() : new Schema<Doc>({});
+
+  schema.plugin(plugin, pluginOptions);
+
+  const modelInstance = mongoose.model<Doc>(modelName, schema);
+
+  return { model: modelInstance, schema };
+};

package/tsconfig.build.json

@@ -6,5 +6,5 @@
     "outDir": "./dist",
     "rootDir": "./src"
   },
-  "exclude": ["node_modules", "dist", "src/**/*.spec.ts"]
+  "exclude": ["node_modules", "dist", "src/**/*.spec.ts", "src/test-utils/**"]
 }