@opinio-dev/models 1.1.1-item-types.5 → 1.1.1-item-types.6

package/dist/types/items/Book.js

@@ -0,0 +1,8 @@
+/**
+ * Determines if the given item is a book
+ * @param {Item} item The item to check
+ * @returns {boolean} True if the item is a book, false otherwise
+ */
+export function isBook(item) {
+    return item.type === 'book';
+}

package/dist/types/items/Game.js

@@ -0,0 +1,8 @@
+/**
+ * Determines if the given item is a game
+ * @param {Item} item The item to check
+ * @returns {boolean} True if the item is a game, false otherwise
+ */
+export function isGame(item) {
+    return item.type === 'game';
+}

package/dist/types/items/Genre.js

@@ -0,0 +1,66 @@
+export const VideoGenres = [
+    'Action',
+    'Adventure',
+    'Biography',
+    'Comedy',
+    'Drama',
+    'Fantasy',
+    'Horror',
+    'Mystery',
+    'Romance',
+    'Science Fiction',
+    'Thriller',
+    'Crime',
+    'Documentary',
+    'Animation',
+    'Family',
+    'Historical',
+    'Musical',
+    'War',
+    'Western'
+];
+export const GameGenres = [
+    ...VideoGenres,
+    'RPG',
+    'Shooter',
+    'Fighting',
+    'Platformer',
+    'Puzzle',
+    'Open World',
+    'Racing',
+    'Simulation',
+    'Sports',
+    'Strategy',
+    'Survival',
+    'Sandbox',
+    'MOBA',
+    'MMO',
+    'Roguelike'
+];
+export const BookGenres = [
+    'Fiction',
+    'Non-Fiction',
+    'Fantasy',
+    'Science Fiction',
+    'Mystery',
+    'Thriller',
+    'Horror',
+    'Romance',
+    'Historical',
+    'Biography',
+    'Autobiography',
+    'Memoir',
+    'Self-Help',
+    'Poetry',
+    'Drama',
+    'Young Adult',
+    "Children's",
+    'Graphic Novel',
+    'Classic',
+    'Philosophy',
+    'Science',
+    'Travel',
+    'Religion',
+    'True Crime',
+    'Humor'
+];

package/dist/types/items/Item.js

@@ -0,0 +1 @@
+export {};

package/dist/types/items/ItemType.js

@@ -0,0 +1,15 @@
+export const ItemType = {
+    Book: 'book',
+    Game: 'game',
+    Movie: 'movie',
+    Series: 'series'
+};
+export const ItemTypes = Object.values(ItemType);
+/**
+ * Determines if the item type is valid
+ * @param {string|ItemType} itemType The item type to check
+ * @returns {boolean} Whether the item type is valid
+ */
+export function isItemType(itemType) {
+    return ItemTypes.includes(itemType);
+}

package/dist/types/items/Movie.js

@@ -0,0 +1,8 @@
+/**
+ * Determines if the given item is a movie
+ * @param {Item} item The item to check
+ * @returns {boolean} True if the item is a movie, false otherwise
+ */
+export function isMovie(item) {
+    return item.type === 'movie';
+}

package/dist/types/items/Series.js

@@ -0,0 +1,9 @@
+export const SeriesStatuses = ['ongoing', 'completed', 'cancelled'];
+/**
+ * Determines if the given item is a series
+ * @param {Item} item The item to check
+ * @returns {boolean} True if the item is a series, false otherwise
+ */
+export function isSeries(item) {
+    return item.type === 'series';
+}

package/dist/types/ratings/LeaderboardItem.js

@@ -0,0 +1 @@
+export {};

package/dist/types/ratings/LeaderboardSnapshot.js

@@ -0,0 +1 @@
+export {};

package/dist/types/ratings/Rating.js

@@ -0,0 +1 @@
+export {};

package/dist/validation/BaseValidator.js

@@ -0,0 +1,43 @@
+/**
+ * A base validator providing common validation logic.
+ */
+export class BaseValidator {
+    /**
+     * @inheritdoc
+     */
+    validate(item, ignoredFields) {
+        const errors = this._validateFields(item);
+        const filteredErrors = this.__filterIgnoredFields(errors, ignoredFields);
+        return this.__createValidationResult(filteredErrors);
+    }
+    /**
+     * Filters out errors for ignored fields.
+     * @template T The type of the item being validated.
+     * @param {Record<string, string>} errors The errors to filter.
+     * @param {Array<keyof T>} ignoredFields Fields to ignore during validation.
+     * @returns {Record<string, string>} The filtered errors.
+     */
+    __filterIgnoredFields(errors, ignoredFields) {
+        if (!ignoredFields || ignoredFields.length === 0) {
+            return errors;
+        }
+        const filteredErrors = {};
+        for (const [field, error] of Object.entries(errors)) {
+            if (!ignoredFields.includes(field)) {
+                filteredErrors[field] = error;
+            }
+        }
+        return filteredErrors;
+    }
+    /**
+     * Creates a validation result from errors.
+     * @param {Record<string, string>} errors The validation errors.
+     * @returns {IValidationResult} The validation result.
+     */
+    __createValidationResult(errors) {
+        return {
+            valid: Object.keys(errors).length === 0,
+            errors
+        };
+    }
+}

package/dist/validation/ValidationResult.js

@@ -0,0 +1 @@
+export {};

package/dist/validation/Validator.js

@@ -0,0 +1 @@
+export {};

package/dist/validation/ValidatorRegistry.js

@@ -0,0 +1,29 @@
+/**
+ * A registry for managing validators.
+ */
+export class ValidatorRegistry {
+    validators = new Map();
+    /**
+     * Retrieves a validator.
+     * @param {string} key The key of the validator to retrieve.
+     * @param {IValidator<T>} validator The validator to register.
+     * @returns {void}
+     */
+    register(key, validator) {
+        this.validators.set(key, validator);
+    }
+    /**
+     * Validates an item using a registered validator.
+     * @param {string} key The key of the validator to use.
+     * @param {Partial<T>} item The item to validate.
+     * @param {Array<keyof T>=} ignoredFields Fields to ignore during validation.
+     * @returns {IValidationResult} The result of the validation.
+     */
+    validate(key, item, ignoredFields) {
+        const validator = this.validators.get(key);
+        if (!validator) {
+            throw new Error(`Validator with key ${key} not found.`);
+        }
+        return validator.validate(item, ignoredFields);
+    }
+}

package/dist/validation/items/BaseItemValidator.js

@@ -0,0 +1,41 @@
+import { ItemTypes } from '../../types/items/ItemType';
+import { BaseValidator } from '../BaseValidator';
+/**
+ * A base validator for items, providing common validation logic.
+ */
+export class BaseItemValidator extends BaseValidator {
+    /**
+     * @inheritdoc
+     */
+    _validateFields(item) {
+        const baseResult = this._validateBaseFields(item);
+        const typeResult = this._validateTypeSpecificFields(item);
+        return { ...baseResult, ...typeResult };
+    }
+    /**
+     * Validates common item fields that apply to all item types.
+     * @param {Partial<T>} item The item to validate.
+     * @returns {Record<string, string>} A record of validation errors.
+     */
+    _validateBaseFields(item) {
+        const { id, type, name, releaseYear } = item;
+        const errors = {};
+        if (!id) {
+            errors.id = 'Item id is required';
+        }
+        if (!type) {
+            errors.type = 'Item type is required';
+        }
+        if (type && !ItemTypes.includes(type)) {
+            errors.type = `Item type must be one of: ${ItemTypes.join(', ')}`;
+        }
+        if (!name) {
+            errors.name = 'Item name is required';
+        }
+        const currentYear = new Date().getFullYear();
+        if (releaseYear && (releaseYear < 1800 || releaseYear > currentYear)) {
+            errors.releaseYear = `Release year must be between 1800 and ${currentYear}`;
+        }
+        return errors;
+    }
+}

package/dist/validation/items/BookValidator.js

@@ -0,0 +1,27 @@
+import { BookGenres } from '../../types/items/Genre';
+import { BaseItemValidator } from './BaseItemValidator';
+/**
+ * A validator for book items.
+ */
+export class BookValidator extends BaseItemValidator {
+    /**
+     * @inheritdoc
+     */
+    _validateTypeSpecificFields(book) {
+        const { genres, author, publisher } = book;
+        const errors = {};
+        if (!genres?.length) {
+            errors.genres = 'Book genres are required';
+        }
+        if (!genres?.every((genre) => !BookGenres.includes(genre))) {
+            errors.genres = `One or more book genres are invalid. Valid genres are: ${BookGenres.join(', ')}`;
+        }
+        if (!author) {
+            errors.author = 'Book author is required';
+        }
+        if (!publisher) {
+            errors.publisher = 'Book publisher is required';
+        }
+        return errors;
+    }
+}

package/dist/validation/items/GameValidator.js

@@ -0,0 +1,30 @@
+import { GameGenres } from '../../types/items/Genre';
+import { BaseItemValidator } from './BaseItemValidator';
+/**
+ * A validator for game items.
+ */
+export class GameValidator extends BaseItemValidator {
+    /**
+     * @inheritdoc
+     */
+    _validateTypeSpecificFields(game) {
+        const { genres, platforms, developer, publisher } = game;
+        const errors = {};
+        if (!genres?.length) {
+            errors.genres = 'Game genres are required';
+        }
+        if (!genres?.every((genre) => !GameGenres.includes(genre))) {
+            errors.genres = `One or more game genres are invalid. Valid genres are: ${GameGenres.join(', ')}`;
+        }
+        if (!platforms?.length) {
+            errors.platforms = 'Game platforms are required';
+        }
+        if (!developer) {
+            errors.developer = 'Game developer is required';
+        }
+        if (!publisher) {
+            errors.publisher = 'Game publisher is required';
+        }
+        return errors;
+    }
+}

package/dist/validation/items/ItemValidatorRegistry.js

@@ -0,0 +1,10 @@
+import { ValidatorRegistry } from '../ValidatorRegistry';
+import { BookValidator } from './BookValidator';
+import { GameValidator } from './GameValidator';
+import { MovieValidator } from './MovieValidator';
+import { SeriesValidator } from './SeriesValidator';
+export const ItemValidatorRegistry = new ValidatorRegistry();
+ItemValidatorRegistry.register('movie', new MovieValidator());
+ItemValidatorRegistry.register('series', new SeriesValidator());
+ItemValidatorRegistry.register('game', new GameValidator());
+ItemValidatorRegistry.register('book', new BookValidator());

package/dist/validation/items/MovieValidator.js

@@ -0,0 +1,33 @@
+import { VideoGenres } from '../../types/items/Genre';
+import { BaseItemValidator } from './BaseItemValidator';
+/**
+ * A validator for movie items.
+ */
+export class MovieValidator extends BaseItemValidator {
+    /**
+     * @inheritdoc
+     */
+    _validateTypeSpecificFields(movie) {
+        const { genres, director, duration, cast } = movie;
+        const errors = {};
+        if (!genres?.length) {
+            errors.genres = 'Movie genres are required';
+        }
+        if (!genres?.every((genre) => !VideoGenres.includes(genre))) {
+            errors.genres = `One or more movie genres are invalid. Valid genres are: ${VideoGenres.join(', ')}`;
+        }
+        if (duration === undefined) {
+            errors.duration = 'Movie duration is required';
+        }
+        if (duration !== undefined && duration <= 0) {
+            errors.duration = 'Movie duration is invalid. Duration must be a positive number.';
+        }
+        if (!director) {
+            errors.director = 'Movie director is required';
+        }
+        if (!cast?.length) {
+            errors.cast = 'Movie cast is required';
+        }
+        return errors;
+    }
+}

package/dist/validation/items/SeriesValidator.js

@@ -0,0 +1,40 @@
+import { VideoGenres } from '../../types/items/Genre';
+import { SeriesStatuses } from '../../types/items/Series';
+import { BaseItemValidator } from './BaseItemValidator';
+/**
+ * A validator for series items.
+ */
+export class SeriesValidator extends BaseItemValidator {
+    /**
+     * @inheritdoc
+     */
+    _validateTypeSpecificFields(series) {
+        const { genres, status, seasons, creator, cast } = series;
+        const errors = {};
+        if (!genres?.length) {
+            errors.genres = 'Series genres are required';
+        }
+        if (!genres?.every((genre) => !VideoGenres.includes(genre))) {
+            errors.genres = `One or more series genres are invalid. Valid genres are: ${VideoGenres.join(', ')}`;
+        }
+        if (!status) {
+            errors.status = 'Series status is required';
+        }
+        if (status && !SeriesStatuses.includes(status)) {
+            errors.status = `Series status is invalid. Valid statuses are: ${SeriesStatuses.join(', ')}`;
+        }
+        if (seasons === undefined) {
+            errors.seasons = 'Series seasons is required';
+        }
+        if (seasons !== undefined && seasons <= 0) {
+            errors.seasons = 'Series seasons is invalid. Seasons must be a positive number.';
+        }
+        if (!creator) {
+            errors.creator = 'Series creator is required';
+        }
+        if (!cast?.length) {
+            errors.cast = 'Series cast is required';
+        }
+        return errors;
+    }
+}

package/dist/validation/ratings/LeaderboardItemValidator.js

@@ -0,0 +1,35 @@
+import { BaseValidator } from '../BaseValidator';
+/**
+ * A validator for item leaderboardItems.
+ */
+export class LeaderboardItemValidator extends BaseValidator {
+    /**
+     * @inheritdoc
+     */
+    _validateFields(leaderboardItem) {
+        const { id, itemId, rank, rating, numberOfRatings } = leaderboardItem;
+        const errors = {};
+        if (!id) {
+            errors.id = 'Rating id is required';
+        }
+        if (!itemId) {
+            errors.itemId = 'Item id is required for the leaderboardItem';
+        }
+        if (rank === undefined || rank === null) {
+            errors.rank = 'LeaderboardItem rank is required';
+        }
+        if (rating === undefined || rating === null) {
+            errors.rating = 'LeaderboardItem rating is required';
+        }
+        if (rating && rating < 1) {
+            errors.rating = 'LeaderboardItem rating must be a positive number';
+        }
+        if (numberOfRatings === undefined || numberOfRatings === null) {
+            errors.rating = 'Number of ratings is required';
+        }
+        if (numberOfRatings && numberOfRatings < 1) {
+            errors.rating = 'Number of ratings must be a positive number';
+        }
+        return errors;
+    }
+}

package/dist/validation/ratings/LeaderboardSnapshotValidator.js

@@ -0,0 +1,30 @@
+import { ItemTypes } from '../../types/items/ItemType';
+import { BaseValidator } from '../BaseValidator';
+/**
+ * A validator for item leaderboardSnapshots.
+ */
+export class LeaderboardSnapshotValidator extends BaseValidator {
+    /**
+     * @inheritdoc
+     */
+    _validateFields(leaderboardSnapshot) {
+        const { id, itemType, leaderboardItems, date } = leaderboardSnapshot;
+        const errors = {};
+        if (!id) {
+            errors.id = 'Rating id is required';
+        }
+        if (itemType === undefined || itemType === null) {
+            errors.itemType = 'LeaderboardSnapshot itemType is required';
+        }
+        if (itemType && !ItemTypes.includes(itemType)) {
+            errors.itemType = `LeaderboardSnapshot itemType must be one of: ${ItemTypes.join(', ')}`;
+        }
+        if (!leaderboardItems) {
+            errors.leaderboardItems = 'Leaderboard items are required';
+        }
+        if (!date) {
+            errors.date = 'Rating date is required';
+        }
+        return errors;
+    }
+}

package/dist/validation/ratings/RatingValidator.js

@@ -0,0 +1,32 @@
+import { BaseValidator } from '../BaseValidator';
+/**
+ * A validator for item ratings.
+ */
+export class RatingValidator extends BaseValidator {
+    /**
+     * @inheritdoc
+     */
+    _validateFields(rating) {
+        const { id, value, itemId, userId, date } = rating;
+        const errors = {};
+        if (!id) {
+            errors.id = 'Rating id is required';
+        }
+        if (value === undefined || value === null) {
+            errors.value = 'Rating value is required';
+        }
+        if (value && (value < 1 || value > 100)) {
+            errors.value = 'Rating value must be between 1 and 100 (inclusive)';
+        }
+        if (!itemId) {
+            errors.itemId = 'Item id is required for the rating';
+        }
+        if (!userId) {
+            errors.userId = 'User id is required for the rating';
+        }
+        if (!date) {
+            errors.date = 'Rating date is required';
+        }
+        return errors;
+    }
+}

package/package.json

@@ -1,19 +1,18 @@
 {
   "name": "@opinio-dev/models",
-  "version": "1.1.1-item-types.5",
+  "version": "1.1.1-item-types.6",
   "type": "module",
   "files": [
     "dist"
   ],
   "exports": {
-    "./types/*": "./dist/types/*.d.ts",
-    "./validation/*": "./dist/validation/*.js"
+    ".": "./dist"
   },
   "scripts": {
     "lint": "eslint .",
     "format": "prettier --write .",
     "format:check": "prettier --check .",
-    "build": "rimraf dist && node build.js && tsc",
+    "build": "rimraf dist && tsc",
     "build:ts": "tsc --noEmit",
     "publish": "npm run build && npm publish --access public --ignore-scripts",
     "prepare": "husky"
@@ -23,7 +22,6 @@
   "description": "",
   "devDependencies": {
     "@eslint/js": "^9.33.0",
-    "esbuild": "^0.27.0",
     "eslint": "^9.33.0",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-import": "^2.32.0",