@slango/mangusta 2.1.40 → 2.1.41

package/src/middleware/reactions.ts

@@ -1,371 +0,0 @@
-import { Document, Model, Schema, Types } from 'mongoose';
-
-import { Id, toObjectId, toStringId } from '../helpers.js';
-import { PluginFunction } from '../types.js';
-
-export const defaultReactionTypes = ['👍', '❤️', '🤔', '😂', '😮'] as const;
-
-export type ReactionType = (typeof defaultReactionTypes)[number];
-
-export interface ReactionCountSummary {
-  perType: Record<string, number>;
-  total: number;
-}
-
-export type ReactionUserField<UserField extends string = 'user'> = {
-  [key in UserField]: Types.ObjectId;
-};
-
-export type ReactionTypeField<TypeField extends string = 'type'> = {
-  [key in TypeField]: string;
-};
-
-export type ReactionTimestampField<TimestampField extends string = 'createdAt'> = {
-  [key in TimestampField]?: Date;
-};
-
-export type ReactionEntry<
-  UserField extends string = 'user',
-  TypeField extends string = 'type',
-  TimestampField extends string = 'createdAt',
-> = ReactionTimestampField<TimestampField> &
-  ReactionTypeField<TypeField> &
-  ReactionUserField<UserField>;
-
-export type WithReactions<
-  Field extends string = 'reactions',
-  UserField extends string = 'user',
-  TypeField extends string = 'type',
-  TimestampField extends string = 'createdAt',
-> = {
-  [key in Field]: ReactionEntry<UserField, TypeField, TimestampField>[];
-};
-
-export interface WithReactionsMethods {
-  addReaction(user: Id, type: string, timestampValue?: Date): this;
-  countReactions(type?: string): number | ReactionCountSummary;
-  hasReaction(user: Id, type?: string): boolean;
-  removeReaction(user: Id, type?: string): this;
-}
-
-export interface ReactionsMiddlewareOptions<
-  Field extends string = 'reactions',
-  UserField extends string = 'user',
-  TypeField extends string = 'type',
-  TimestampField extends string = 'createdAt',
-> {
-  allowedTypes?: readonly string[];
-  allowMultiplePerUser?: boolean;
-  field?: Field;
-  indexType?: -1 | 1 | boolean;
-  indexUser?: -1 | 1 | boolean;
-  timestamp?: boolean;
-  timestampField?: TimestampField;
-  typeField?: TypeField;
-  userField?: UserField;
-  userRef?: string;
-}
-
-const reactionsMiddleware: PluginFunction<ReactionsMiddlewareOptions> = <
-  Field extends string = 'reactions',
-  UserField extends string = 'user',
-  TypeField extends string = 'type',
-  TimestampField extends string = 'createdAt',
-  DocType extends Document &
-    WithReactions<Field, UserField, TypeField, TimestampField> &
-    WithReactionsMethods = Document &
-    WithReactions<Field, UserField, TypeField, TimestampField> &
-    WithReactionsMethods,
->(
-  schema: Schema<DocType, Model<DocType>>,
-  {
-    allowedTypes = defaultReactionTypes,
-    allowMultiplePerUser = false,
-    field = 'reactions' as Field,
-    indexType = false,
-    indexUser = true,
-    timestamp = true,
-    timestampField = 'createdAt' as TimestampField,
-    typeField = 'type' as TypeField,
-    userField = 'user' as UserField,
-    userRef = 'User',
-  }: ReactionsMiddlewareOptions<Field, UserField, TypeField, TimestampField> = {},
-): void => {
-  const allowedTypesSet = new Set(allowedTypes);
-  const shouldEnforceAllowedTypes = allowedTypesSet.size > 0;
-
-  const reactionSchemaDefinition: Record<string, unknown> = {
-    [userField]: {
-      ref: userRef,
-      required: true,
-      type: Types.ObjectId,
-    },
-    [typeField]: {
-      required: true,
-      type: String,
-      ...(shouldEnforceAllowedTypes && { enum: Array.from(allowedTypesSet) }),
-    },
-    ...(timestamp && {
-      [timestampField]: {
-        default: Date.now,
-        type: Date,
-      },
-    }),
-  };
-
-  const reactionsSubSchema = new Schema<ReactionEntry<UserField, TypeField, TimestampField>>(
-    reactionSchemaDefinition,
-    {
-      _id: false,
-    },
-  );
-
-  schema.add(
-    new Schema<WithReactions<Field, UserField, TypeField, TimestampField>>({
-      [field]: {
-        default: [],
-        type: [reactionsSubSchema],
-      },
-    }),
-  );
-
-  if (indexUser) {
-    schema.index({ [`${field}.${userField}`]: indexUser === true ? 1 : indexUser });
-  }
-
-  if (indexType) {
-    schema.index({ [`${field}.${typeField}`]: indexType === true ? 1 : indexType });
-  }
-
-  const ensureAllowedType = (reactionType: string): void => {
-    if (shouldEnforceAllowedTypes && !allowedTypesSet.has(reactionType)) {
-      throw new Error(`Reaction type "${reactionType}" is not permitted.`);
-    }
-  };
-
-  const normalizeEntry = (
-    entry: ReactionEntry<UserField, TypeField, TimestampField>,
-  ): null | ReactionEntry<UserField, TypeField, TimestampField> => {
-    const userValue = entry[userField];
-    const typeValue = entry[typeField];
-
-    if (!userValue || !typeValue) {
-      return null;
-    }
-
-    ensureAllowedType(typeValue);
-
-    const normalized: ReactionEntry<UserField, TypeField, TimestampField> = {
-      ...entry,
-      [userField]: toObjectId(userValue),
-      [typeField]: typeValue,
-    };
-
-    const rawTimestamp = entry[timestampField] as unknown;
-
-    if (timestamp) {
-      if (rawTimestamp instanceof Date) {
-        normalized[timestampField] = rawTimestamp as ReactionEntry<
-          UserField,
-          TypeField,
-          TimestampField
-        >[TimestampField];
-      } else if (rawTimestamp === undefined) {
-        normalized[timestampField] = new Date() as ReactionEntry<
-          UserField,
-          TypeField,
-          TimestampField
-        >[TimestampField];
-      } else if (typeof rawTimestamp === 'string' || typeof rawTimestamp === 'number') {
-        normalized[timestampField] = new Date(rawTimestamp) as ReactionEntry<
-          UserField,
-          TypeField,
-          TimestampField
-        >[TimestampField];
-      }
-    } else if (rawTimestamp !== undefined) {
-      delete (normalized as Record<string, unknown>)[timestampField];
-    }
-
-    return normalized;
-  };
-
-  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;
-      }
-
-      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 {
-        normalizedEntries.push(normalized);
-      }
-    }
-
-    if (normalizedEntries.length !== existing.length || modified) {
-      this.set(field, normalizedEntries);
-    }
-  });
-
-  schema.methods.addReaction = function addReaction(
-    this: DocType,
-    user: Id,
-    reactionType: string,
-    timestampValue?: Date,
-  ): DocType {
-    ensureAllowedType(reactionType);
-
-    const userId = toObjectId(user);
-    const userKey = userId.toString();
-    const reactions = (
-      (this.get(field) as ReactionEntry<UserField, TypeField, TimestampField>[]) ?? []
-    )
-      .map((entry) => normalizeEntry(entry))
-      .filter(
-        (entry): entry is ReactionEntry<UserField, TypeField, TimestampField> => entry !== null,
-      );
-
-    if (!allowMultiplePerUser) {
-      const existingIndex = reactions.findIndex(
-        (entry) => entry[userField]?.toString() === userKey,
-      );
-
-      const newEntry: ReactionEntry<UserField, TypeField, TimestampField> = {
-        [userField]: userId,
-        [typeField]: reactionType,
-      } as ReactionEntry<UserField, TypeField, TimestampField>;
-
-      if (timestamp) {
-        newEntry[timestampField] = (timestampValue ?? new Date()) as ReactionEntry<
-          UserField,
-          TypeField,
-          TimestampField
-        >[TimestampField];
-      }
-
-      if (existingIndex !== -1) {
-        reactions[existingIndex] = newEntry;
-      } else {
-        reactions.push(newEntry);
-      }
-    } else {
-      const newEntry: ReactionEntry<UserField, TypeField, TimestampField> = {
-        [userField]: userId,
-        [typeField]: reactionType,
-      } as ReactionEntry<UserField, TypeField, TimestampField>;
-
-      if (timestamp) {
-        newEntry[timestampField] = (timestampValue ?? new Date()) as ReactionEntry<
-          UserField,
-          TypeField,
-          TimestampField
-        >[TimestampField];
-      }
-
-      reactions.push(newEntry);
-    }
-
-    this.set(field, reactions);
-
-    return this;
-  };
-
-  schema.methods.removeReaction = function removeReaction(
-    this: DocType,
-    user: Id,
-    reactionType?: string,
-  ): DocType {
-    const userKey = toStringId(user);
-    const reactions =
-      (this.get(field) as ReactionEntry<UserField, TypeField, TimestampField>[] | undefined) ?? [];
-
-    const filtered = reactions.filter((entry) => {
-      const matchesUser = entry[userField]?.toString() === userKey;
-      if (!matchesUser) {
-        return true;
-      }
-
-      if (!reactionType) {
-        return false;
-      }
-
-      return entry[typeField] !== reactionType;
-    });
-
-    if (filtered.length !== reactions.length) {
-      this.set(field, filtered);
-    }
-
-    return this;
-  };
-
-  schema.methods.hasReaction = function hasReaction(
-    this: DocType,
-    user: Id,
-    reactionType?: string,
-  ): boolean {
-    const userKey = toStringId(user);
-    const reactions =
-      (this.get(field) as ReactionEntry<UserField, TypeField, TimestampField>[] | undefined) ?? [];
-
-    return reactions.some((entry) => {
-      if (entry[userField]?.toString() !== userKey) {
-        return false;
-      }
-
-      if (reactionType) {
-        return entry[typeField] === reactionType;
-      }
-
-      return true;
-    });
-  };
-
-  schema.methods.countReactions = function countReactions(
-    this: DocType,
-    reactionType?: string,
-  ): number | ReactionCountSummary {
-    const reactions =
-      (this.get(field) as ReactionEntry<UserField, TypeField, TimestampField>[] | undefined) ?? [];
-
-    if (reactionType) {
-      ensureAllowedType(reactionType);
-      return reactions.filter((entry) => entry[typeField] === reactionType).length;
-    }
-
-    return reactions.reduce<ReactionCountSummary>(
-      (accumulator, entry) => {
-        const type = entry[typeField];
-        accumulator.perType[type] = (accumulator.perType[type] ?? 0) + 1;
-        accumulator.total += 1;
-        return accumulator;
-      },
-      { total: 0, perType: {} },
-    );
-  };
-};
-
-export default reactionsMiddleware;

package/src/middleware/tags.spec.ts

@@ -1,103 +0,0 @@
-import mongoose, { Document } 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 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>) =>
-  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 { model: TestModel } = createTestModel();
-    const doc = new TestModel({ tags: ['tag1', 'tag2'] });
-
-    await expect(doc.save()).resolves.not.toThrow();
-    const savedDoc = await TestModel.findOne({ _id: doc._id });
-
-    expect(savedDoc).toBeDefined();
-    expect(savedDoc?.tags).toEqual(['tag1', 'tag2']);
-  });
-
-  it('should add a "tags" field with empty array if no tag is provided', async () => {
-    const { model: TestModel } = createTestModel();
-    const doc = new TestModel({});
-
-    await expect(doc.save()).resolves.not.toThrow();
-    const savedDoc = await TestModel.findOne({ _id: doc._id });
-
-    expect(savedDoc).toBeDefined();
-    expect(savedDoc?.tags).toEqual([]);
-  });
-
-  it('should ensure uniqueness of tags if "unique" is set to true', async () => {
-    const { model: TestModel } = createTestModel({ unique: true });
-    const doc = new TestModel({ tags: ['tag1', 'tag2', 'tag1'] });
-
-    await expect(doc.save()).resolves.not.toThrow();
-    const savedDoc = await TestModel.findOne({ _id: doc._id });
-
-    expect(savedDoc).toBeDefined();
-    expect(savedDoc?.tags).toEqual(['tag1', 'tag2']); // Duplicates removed
-  });
-
-  it('should not enforce uniqueness if "unique" is set to false', async () => {
-    const { model: TestModel } = createTestModel({ unique: false });
-    const doc = new TestModel({ tags: ['tag1', 'tag2', 'tag1'] });
-
-    await expect(doc.save()).resolves.not.toThrow();
-    const savedDoc = await TestModel.findOne({ _id: doc._id });
-
-    expect(savedDoc).toBeDefined();
-    expect(savedDoc?.tags).toEqual(['tag1', 'tag2', 'tag1']);
-  });
-
-  it('should validate tags with custom validation function', async () => {
-    const { model: TestModel } = createTestModel({
-      validate: (tags) => tags.every((tag) => tag.startsWith('valid')),
-    });
-
-    const validDoc = new TestModel({ tags: ['validTag1', 'validTag2'] });
-    await expect(validDoc.save()).resolves.not.toThrow();
-
-    const invalidDoc = new TestModel({ tags: ['validTag', 'invalidTag'] });
-    await expect(invalidDoc.save()).rejects.toThrowError(mongoose.Error.ValidationError);
-  });
-
-  it('should allow configuring the field name', async () => {
-    const { model: TestModel } = createTestModel<'customTags'>({ field: 'customTags' });
-    const doc = new TestModel({ customTags: ['tag1', 'tag2'] });
-
-    await expect(doc.save()).resolves.not.toThrow();
-    const savedDoc = await TestModel.findOne({ _id: doc._id });
-
-    expect(savedDoc).toBeDefined();
-    expect(savedDoc?.customTags).toEqual(['tag1', 'tag2']);
-  });
-
-  it('should add a text index when index is set to "text"', () => {
-    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 { schema } = createTestModel({ index: 'hashed' });
-    const indexes = schema.indexes();
-
-    const textIndex = indexes.find(([fields]) => fields.tags === 'hashed');
-    expect(textIndex).toBeDefined();
-  });
-});

package/src/middleware/tags.ts

@@ -1,54 +0,0 @@
-import { Document, Model, Schema } from 'mongoose';
-
-import { PluginFunction } from '../types.js';
-
-export interface TagsMiddlewareOptions<Field extends string = 'tags'> {
-  field?: Field;
-  index?: 'hashed' | 'text' | false;
-  unique?: boolean;
-  validate?: (tags: string[]) => boolean;
-}
-
-export type WithTags<Field extends string = 'tags'> = {
-  [key in Field]: string[];
-};
-
-const tagsMiddleware: PluginFunction<TagsMiddlewareOptions> = <
-  Field extends string = 'tags',
-  DocType extends Document & WithTags<Field> = Document & WithTags<Field>,
->(
-  schema: Schema<DocType, Model<DocType>>,
-  {
-    field = 'tags' as Field,
-    index = false,
-    unique = true,
-    validate,
-  }: TagsMiddlewareOptions<Field> = {},
-): void => {
-  const tagsSchema = new Schema<WithTags<Field>>({
-    [field]: {
-      type: [String],
-      ...(validate && {
-        validate: {
-          message: 'Tags failed custom validation.',
-          validator: (tags: string[]) => validate(tags),
-        },
-      }),
-    },
-  });
-
-  schema.add(tagsSchema);
-
-  if (index) {
-    schema.index({ [field]: index });
-  }
-
-  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)));
-    }
-  });
-};
-
-export default tagsMiddleware;

package/src/middleware/timestamps.spec.ts

@@ -1,69 +0,0 @@
-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 { setupMongoTestEnvironment } from '../test-utils/mongooseTestEnvironment.js';
-import timestampsMiddleware, { TimestampsMiddlewareOptions, WithTimestamps } from './timestamps.js';
-
-setupMongoTestEnvironment();
-
-type TestDoc = Document & WithTimestamps & { name: string };
-
-const createTestModel = (options?: TimestampsMiddlewareOptions) =>
-  createModelWithPlugin<TestDoc, TimestampsMiddlewareOptions>({
-    modelName: 'TestDoc',
-    plugin: timestampsMiddleware,
-    pluginOptions: options,
-  });
-
-describe('timestampsMiddleware', () => {
-  it('should store creation and update timestamps correctly on save', async () => {
-    const { model: TestModel } = createTestModel();
-    const doc = new TestModel({ name: 'initial' });
-
-    await expect(doc.save()).resolves.not.toThrow();
-
-    const savedDoc = await TestModel.findById(doc._id);
-    expect(savedDoc).not.toBeNull();
-    if (!savedDoc) return;
-    expect(savedDoc.created).toBeInstanceOf(Date);
-    expect(savedDoc.updated).not.toBeDefined();
-
-    await delay(10);
-    savedDoc.name = 'changed';
-    await expect(savedDoc.save()).resolves.not.toThrow();
-
-    const updatedDoc = await TestModel.findById(doc._id);
-    expect(updatedDoc).not.toBeNull();
-    if (!updatedDoc) return;
-    expect(updatedDoc.created).toEqual(savedDoc.created);
-    expect(updatedDoc.updated).toBeInstanceOf(Date);
-    if (!updatedDoc.created || !updatedDoc.updated) return;
-    expect(updatedDoc.updated.getTime()).toBeGreaterThan(updatedDoc.created.getTime());
-  });
-
-  it('should update timestamp when using updateOne operations', async () => {
-    const { model: TestModel } = createTestModel();
-    const doc = new TestModel({ name: 'initial' });
-    await doc.save();
-
-    await delay(10);
-    await TestModel.updateOne({ _id: doc._id }, { name: 'updated' });
-
-    const updatedDoc = await TestModel.findById(doc._id);
-    expect(updatedDoc).not.toBeNull();
-    if (!updatedDoc) return;
-    expect(updatedDoc.updated).not.toBeDefined();
-    if (!updatedDoc.created || !updatedDoc.updated) return;
-    expect(updatedDoc.updated.getTime()).toBeGreaterThan(updatedDoc.created.getTime());
-  });
-
-  it('should add an index on the update field when indexUpdate is true', () => {
-    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

@@ -1,92 +0,0 @@
-import { Document, Model, Schema } from 'mongoose';
-
-import { PluginFunction } from '../types.js';
-
-export interface TimestampsMiddlewareOptions {
-  creation?: boolean;
-  creationField?: string;
-  indexCreation?: boolean;
-  indexUpdate?: boolean;
-  update?: boolean;
-  updateField?: string;
-  updateTimestampOnCreation?: boolean;
-}
-
-export type WithCreated<Field extends string = 'created'> = { [key in Field]: Date };
-
-export type WithTimestamps<
-  Created extends string = 'created',
-  Updated extends string = 'updated',
-> = WithCreated<Created> & WithUpdated<Updated>;
-
-export type WithUpdated<Field extends string = 'updated'> = { [key in Field]?: Date };
-
-const timestampsMiddleware: PluginFunction<TimestampsMiddlewareOptions> = <
-  Created extends string = 'created',
-  Updated extends string = 'updated',
-  DocType extends Document & WithTimestamps<Created, Updated> = Document &
-    WithTimestamps<Created, Updated>,
->(
-  schema: Schema<DocType, Model<DocType>>,
-  {
-    creation = true,
-    creationField = 'created',
-    indexCreation = false,
-    indexUpdate = false,
-    update = true,
-    updateField = 'updated',
-    updateTimestampOnCreation = false,
-  }: TimestampsMiddlewareOptions = {},
-): void => {
-  if (creation) {
-    schema.add(
-      new Schema<WithCreated<Created>>({
-        [creationField]: Date,
-      }),
-    );
-  }
-
-  if (update) {
-    schema.add(
-      new Schema<WithUpdated<Updated>>({
-        [updateField]: 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 (update) {
-      if (this.isNew) {
-        if (updateTimestampOnCreation) {
-          this.set(updateField, now);
-        }
-        // else: do nothing so it's undefined
-      } else {
-        this.set(updateField, now);
-      }
-    }
-  });
-
-  if (update) {
-    schema.pre(['updateOne', 'findOneAndUpdate'], function schemaWithTimestampsPreUpdate() {
-      // ensure $set exists and we don't stomp on other operators
-      this.set({ $set: { [updateField]: new Date() } });
-    });
-  }
-
-  if (creation && indexCreation !== false) {
-    schema.path(creationField).index(indexCreation);
-  }
-
-  if (update && indexUpdate !== false) {
-    schema.path(updateField).index(indexUpdate);
-  }
-};
-
-export default timestampsMiddleware;