@acodeninja/persist 2.2.1 → 2.2.2

package/src/type/complex/CustomType.js

@@ -1,15 +1,49 @@
 import Type from '../Type.js';
 import ajv from 'ajv';
 
-export default class CustomType {
+/**
+ * Represents a custom type definition, allowing the specification of a type based on a given schema.
+ * This class uses AJV (Another JSON Schema Validator) to validate schemas and create type definitions.
+ *
+ * @class CustomType
+ */
+class CustomType {
+    /**
+     * Creates a new custom type definition based on the provided JSON schema.
+     *
+     * The `of` method allows defining a custom object type using a JSON schema. It validates the schema
+     * using AJV to ensure correctness and returns a class representing the custom type.
+     *
+     * @param {Object} schema - The JSON schema that defines the structure and validation rules for the custom type.
+     * @returns {Type} A new class representing the custom type based on the provided schema.
+     *
+     * @example
+     * const customSchema = {
+     *   type: 'object',
+     *   properties: { name: { type: 'string' }, age: { type: 'number' } },
+     *   required: ['name'],
+     * };
+     * const CustomModel = CustomType.of(customSchema);
+     */
     static of(schema) {
+        // Compiles and validates the schema using AJV
         new ajv().compile(schema);
 
+        /**
+         * @class Custom
+         * @extends Type
+         * Represents a custom type defined by a JSON schema.
+         */
         class Custom extends Type {
+            /** @type {string} The data type, which is 'object' */
             static _type = 'object';
+
+            /** @type {Object} The JSON schema that defines the structure and validation rules */
             static _schema = schema;
         }
 
         return Custom;
     }
 }
+
+export default CustomType;

package/src/type/resolved/ResolvedType.js

@@ -1,14 +1,50 @@
 import Type from '../Type.js';
 
-export default class ResolvedType extends Type {
+/**
+ * Class representing a resolved type.
+ *
+ * The `ResolvedType` class extends the base `Type` class and marks the type as resolved.
+ * It provides additional functionality for resolving types and allows creating resolved types based on properties.
+ *
+ * @class ResolvedType
+ * @extends Type
+ */
+class ResolvedType extends Type {
+    /**
+     * @static
+     * @property {boolean} _resolved - Indicates if the type is resolved. Always set to `true` for this class.
+     */
     static _resolved = true;
 
+    /**
+     * Resolves the type based on the provided model.
+     *
+     * This method should be overridden in subclasses to provide specific resolution logic.
+     * Throws an error if not implemented.
+     *
+     * @param {*} _model - The model used to resolve the type.
+     * @throws {Error} If the method is not implemented in a subclass.
+     */
     static resolve(_model) {
         throw new Error(`${this.name} does not implement resolve(model)`);
     }
 
+    /**
+     * Creates a subclass of `ResolvedType` that is based on the provided property.
+     *
+     * The returned class inherits from `ResolvedType` and customizes its `toString` method
+     * to reflect the resolved property.
+     *
+     * @param {*} property - The property to base the resolved type on.
+     * @returns {ResolvedType} A subclass of `ResolvedType` customized for the provided property.
+     */
     static of(property) {
         class ResolvedTypeOf extends ResolvedType {
+            /**
+             * Converts the resolved type to a string, displaying the resolved property.
+             *
+             * @returns {string} A string representing the resolved type, including the property.
+             */
             static toString() {
                 return `ResolvedTypeOf(${property})`;
             }
@@ -17,3 +53,5 @@ export default class ResolvedType extends Type {
         return ResolvedTypeOf;
     }
 }
+
+export default ResolvedType;

package/src/type/resolved/SlugType.js

@@ -1,15 +1,53 @@
 import ResolvedType from './ResolvedType.js';
 import slugify from 'slugify';
 
-export default class SlugType extends ResolvedType {
+/**
+ * Class representing a slug type.
+ *
+ * The `SlugType` class extends the `ResolvedType` and provides functionality for generating
+ * slugified strings based on a specified property of a model. It allows for the creation of
+ * types that resolve into slugs from specific properties.
+ *
+ * @class SlugType
+ * @extends ResolvedType
+ */
+class SlugType extends ResolvedType {
+    /**
+     * Creates a subclass of `ResolvedType` that generates slugs based on the provided property.
+     *
+     * The returned class inherits from `ResolvedType` and resolves the property into a slugified
+     * string using the `slugify` function. It also customizes the `toString` method to reflect
+     * the resolved property.
+     *
+     * @param {string} property - The property to base the slug on.
+     * @returns {ResolvedType} A subclass of `ResolvedType` that generates slugs from the provided property.
+     */
     static of(property) {
         class SlugOf extends ResolvedType {
+            /**
+             * @static
+             * @property {string} _type - The type of the resolved value, always set to 'string' for slug types.
+             */
             static _type = 'string';
 
+            /**
+             * Converts the slug type to a string, displaying the resolved property.
+             *
+             * @returns {string} A string representing the slug type, including the property.
+             */
             static toString() {
                 return `SlugOf(${property})`;
             }
 
+            /**
+             * Resolves the slug from the given model by extracting the specified property and slugifying it.
+             *
+             * If the specified property in the model is not a string, an empty string is returned.
+             * Uses the `slugify` function to convert the property value into a slug (lowercase, hyphen-separated).
+             *
+             * @param {Object} model - The model from which to extract and slugify the property.
+             * @returns {string} The slugified version of the model's property, or an empty string if not valid.
+             */
             static resolve(model) {
                 if (typeof model?.[property] !== 'string') return '';
 
@@ -22,3 +60,5 @@ export default class SlugType extends ResolvedType {
         return SlugOf;
     }
 }
+
+export default SlugType;

package/src/type/simple/BooleanType.js

@@ -1,5 +1,20 @@
 import SimpleType from './SimpleType.js';
 
-export default class BooleanType extends SimpleType {
+/**
+ * Class representing a boolean type.
+ *
+ * This class is used to define and handle data of the boolean type.
+ * It extends the {@link SimpleType} class to represent string-specific behavior.
+ *
+ * @class BooleanType
+ * @extends SimpleType
+ */
+class BooleanType extends SimpleType {
+    /**
+     * @static
+     * @property {string} _type - The type identifier for BooleanType, set to `'boolean'`.
+     */
     static _type = 'boolean';
 }
+
+export default BooleanType;

package/src/type/simple/DateType.js

@@ -1,10 +1,37 @@
 import SimpleType from './SimpleType.js';
 
-export default class DateType extends SimpleType {
+/**
+ * Class representing a date type with ISO date-time format.
+ *
+ * This class is used to define and handle data of the date type.
+ * It extends the {@link SimpleType} class to represent string-specific behavior.
+ *
+ * @class DateType
+ * @extends SimpleType
+ */
+class DateType extends SimpleType {
+    /**
+     * @static
+     * @property {string} _type - The type identifier for DateType, set to `'string'`.
+     */
     static _type = 'string';
+
+    /**
+     * @static
+     * @property {string} _format - The format for DateType, set to `'iso-date-time'`.
+     */
     static _format = 'iso-date-time';
 
+    /**
+     * Checks if the given value is a valid date.
+     *
+     * @static
+     * @param {*} possibleDate - The value to check for a valid date.
+     * @returns {boolean} Returns `true` if the value is a valid date or a date string, otherwise `false`.
+     */
     static isDate(possibleDate) {
         return possibleDate instanceof Date || !isNaN(new Date(possibleDate));
     }
 }
+
+export default DateType;

package/src/type/simple/NumberType.js

@@ -1,5 +1,20 @@
 import SimpleType from './SimpleType.js';
 
-export default class NumberType extends SimpleType {
+/**
+ * Class representing a number type.
+ *
+ * This class is used to define and handle data of the number type.
+ * It extends the {@link SimpleType} class to represent string-specific behavior.
+ *
+ * @class NumberType
+ * @extends SimpleType
+ */
+class NumberType extends SimpleType {
+    /**
+     * @static
+     * @property {string} _type - The type identifier for NumberType, set to `'number'`.
+     */
     static _type = 'number';
 }
+
+export default NumberType;

package/src/type/simple/SimpleType.js

@@ -1,4 +1,14 @@
 import Type from '../Type.js';
 
-export default class SimpleType extends Type {
+/**
+ * Class representing a simple type.
+ *
+ * This serves as a base class for primitive or simple types such as string, number, or boolean.
+ *
+ * @class SimpleType
+ * @extends Type
+ */
+class SimpleType extends Type {
 }
+
+export default SimpleType;

package/src/type/simple/StringType.js

@@ -1,5 +1,20 @@
 import SimpleType from './SimpleType.js';
 
-export default class StringType extends SimpleType {
+/**
+ * Class representing a string type.
+ *
+ * This class is used to define and handle data of the string type.
+ * It extends the {@link SimpleType} class to represent string-specific behavior.
+ *
+ * @class StringType
+ * @extends SimpleType
+ */
+class StringType extends SimpleType {
+    /**
+     * @static
+     * @property {string} _type - The type identifier for the string type.
+     */
     static _type = 'string';
 }
+
+export default StringType;