orm/src/schema/Schema.js

  1. /**
  2.  * @module flitter-orm/src/schema/Schema
  3.  */
  5. const DateType = require('./types/Date')
  6. const StringType = require('./types/String')
  7. const NumberType = require('./types/Number')
  8. const BooleanType = require('./types/Boolean')
  9. const ObjectIdType = require('./types/ObjectId')
  10. const ArrayType = require('./types/Array')
  11. const ObjectType = require('./types/Object')
  12. const ModelType = require('./types/Model')
  13. const Type = require('./Type')
  14. const { ObjectId } = require('mongodb')
  16. /**
  17.  * Database schema base class. Provides logic for parsing
  18.  * and recursively building a schema from a definition, and
  19.  * coercing an object, recursively, to comply with the schema
  20.  * definition.
  21.  */
  22. class Schema {
  24.     /**
  25.      * Schema types supported by this Schema class.
  26.      * Provides a mapping from reference name => Type class.
  27.      * @type {object}
  28.      */
  29.     static types = {
  30.         Date: DateType,
  31.         String: StringType,
  32.         Number: NumberType,
  33.         Boolean: BooleanType,
  34.         ObjectId: ObjectIdType,
  35.         Array: ArrayType,
  36.         Object: ObjectType,
  37.         Model: ModelType,
  38.     }
  40.     /**
  41.      * Instantiates the schema and builds the schema object from the provided definition.
  42.      * @param {object} definition - the schema definition
  43.      */
  44.     constructor(definition = {}) {
  46.         /**
  47.          * The original schema definition.
  48.          * @type {object}
  49.          */
  50.         this.definition = definition
  52.         /**
  53.          * The built schema object.
  54.          * @type {object}
  55.          */
  56.         this.schema = this.build_schema(definition)
  57.     }
  59.     /**
  60.      * Cast the provided object to the specified schema. Particularly,
  61.      * this function is used externally to cast objects to this schema,
  62.      * recursively.
  63.      *
  64.      * After this cast, the resulting object is safe to persist, at least
  65.      * for what this library guarantees.
  66.      *
  67.      * @param {object} object - object to cast
  68.      * @param {object} [level = false] - the current level of the schema object (usually leave this blank)
  69.      * @returns {object} - the casted object
  70.      */
  71.     cast_to_schema(object, level = false) {
  72.         if ( !level ) level = this.schema
  74.         // Special handling for arrays, since their children property is _default
  75.         if ( Array.isArray(object) && '_default' in level ) {
  76.             const cast_array = []
  77.             for ( const item of object ) {
  78.                 cast_array.push(this.cast_to_schema(item, level._default))
  79.             }
  81.             return cast_array
  82.         }
  84.         // Handle single item casts (e.g. cast 'some string' to a string schema)
  85.         if ( typeof object !== 'object' || (level.type && (level.type === ObjectType || level.type === ModelType) ) ) {
  86.             // Handle primitives and object types
  87.             let value
  88.             if ( typeof object !== 'undefined' ) value = level.type.cast(object)
  89.             else {
  90.                 const default_value = level.default_to()
  91.                 if ( typeof default_value !== 'undefined' ) value = level.type.cast(default_value)
  92.             }
  94.             if ( typeof value !== 'undefined' ) {
  95.                 if (level.children) {
  96.                     // Parse the nested type
  97.                     return this.cast_to_schema(value, level.children)
  98.                 } else {
  99.                     // Store the primitive type
  100.                     return value
  101.                 }
  102.             }
  103.         }
  105.         // Handle primitive object casts
  106.         else if (typeof level === 'object' && level.type && level.default_to && level.prop && level.def ) {
  107.             let value
  108.             if ( object ) value = level.type.cast(object)
  109.             else {
  110.                 const default_value = level.default_to()
  111.                 if (typeof default_value !== 'undefined') value = schemata.type.cast(default_value)
  112.             }
  113.             return value
  114.         }
  116.         // Handle object-type casts
  117.         else {
  118.             const cast_object = {}
  119.             for (const prop in level) {
  120.                 const schemata = level[prop]
  121.                 if (!level.hasOwnProperty(prop)) continue
  123.                 // Handle primitives and object types
  124.                 let value
  125.                 if (prop in object) value = schemata.type.cast(object[prop])
  126.                 else {
  127.                     const default_value = schemata.default_to()
  128.                     if (typeof default_value !== 'undefined') value = schemata.type.cast(default_value)
  129.                 }
  131.                 if (typeof value !== 'undefined') {
  132.                     if (schemata.children) {
  133.                         // Parse the nested type
  134.                         cast_object[prop] = this.cast_to_schema(value, schemata.children)
  135.                     } else {
  136.                         // Store the primitive type
  137.                         cast_object[prop] = value
  138.                     }
  139.                 }
  140.             }
  142.             return cast_object
  143.         }
  144.     }
  146.     /**
  147.      * Recursively build a schema object from the provided definition.
  148.      * @param {object} defs - the schema definition
  149.      * @returns {object} - the schema object
  150.      */
  151.     build_schema(defs) {
  152.         const level = {}
  153.         for ( const prop in defs ) {
  154.             const def = defs[prop]
  155.             // Process primitives
  156.             if ( typeof def === 'function' && def.prototype instanceof require('../model/Model') ) {
  157.                 const type = this.parse_type(def)
  158.                 const default_to = this.parse_default()
  159.                 level[prop] = { type, default_to, prop, def, children: this.build_schema(def.schema) }
  160.             }
  161.             else if ( !Array.isArray(def) && typeof def !== 'object' ) {
  162.                 const type = this.parse_type(def)
  163.                 const default_to = this.parse_default()
  164.                 level[prop] = { type, default_to, prop, def }
  165.             }
  166.             // Process primitive objects
  167.             else if ( typeof def === 'object' && def.type && !Array.isArray(def.type) && typeof def.type !== 'object' ) {
  168.                 const type = this.parse_type(def.type)
  169.                 const default_to = this.parse_default(def.default)
  170.                 level[prop] = { type, default_to, prop, def }
  171.             }
  172.             // Process array types
  173.             else if ( Array.isArray(def) ) {
  174.                 const type = this.parse_type(def)
  175.                 const default_to = this.parse_default()
  176.                 level[prop] = { type, default_to, prop, def, children: this.build_schema({_default: def[0]})}
  177.             }
  178.             // Process nested objects
  179.             else {
  180.                 const type = this.parse_type(def)
  181.                 const default_to = this.parse_default()
  182.                 level[prop] = { type, default_to, prop, def, children: this.build_schema(def) }
  183.             }
  184.         }
  185.         return level
  186.     }
  188.     /**
  189.      * Parse the schema type from the specified type identifier.
  190.      * @param {Date|String|Number|Boolean|ObjectId|Array|Object} type
  191.      * @returns {module:flitter-orm/src/schema/Type~Type}
  192.      */
  193.     parse_type(type) {
  194.         const types = this.constructor.types
  195.         if ( [Date, 'date', 'Date'].includes(type) ) return types.Date
  196.         if ( [String, 'string', 'String'].includes(type) ) return types.String
  197.         if ( [Number, 'number', 'Number', 'int', 'Int', 'double', 'Double'].includes(type) ) return types.Number
  198.         if ( [Boolean, 'boolean', 'Boolean'].includes(type) ) return types.Boolean
  199.         if ( [ObjectId, 'ObjectId', 'id'].includes(type) ) return types.ObjectId
  200.         if ( [Array, 'array', 'Array'].includes(type) || Array.isArray(type) ) return types.Array
  201.         if ( [Object, 'object', 'Object'].includes(type) || typeof type === 'object' ) return types.Object
  202.         if ( typeof type === 'function' && type.prototype instanceof require('../model/Model') ) return types.Model
  203.         throw new Error('Unknown or invalid field type encountered!')
  204.     }
  206.     /**
  207.      * Create a function that returns the specified default value.
  208.      * If default_value is a function, it will be called. Otherwise,
  209.      * this will return a function that evaluates to default_value.
  210.      *
  211.      * @param {function|*} default_value
  212.      * @returns {function}
  213.      */
  214.     parse_default(default_value) {
  215.         if ( typeof default_value === 'function' ) return default_value
  216.         else return () => default_value
  217.     }
  218. }
  220. module.exports = exports = Schema
JAVASCRIPT
Copied!