functional-models 1.0.25 → 1.1.0

package/src/models.ts

@@ -0,0 +1,183 @@
+import merge from 'lodash/merge'
+import { toJsonAble } from './serialization'
+import { createModelValidator } from './validation'
+import { UniqueId } from './properties'
+import {
+  Model,
+  InstanceMethodGetters,
+  Nullable,
+  ModelDefinition,
+  ModelInstance,
+  ModelOptions,
+  ReferenceFunctions,
+  PropertyGetters,
+  OptionalModelOptions,
+  ReferencePropertyInstance,
+  ReferenceValueType,
+  PropertyValidators,
+  FunctionalModel,
+  ModelInstanceInputData,
+  ModelInstanceMethodTyped,
+  ModelMethodTyped,
+  ModelMethodGetters,
+} from './interfaces'
+
+const _defaultOptions = (): ModelOptions => ({
+  instanceCreatedCallback: null,
+})
+
+const _convertOptions = (options?: OptionalModelOptions) => {
+  const r: ModelOptions = merge({}, _defaultOptions(), options)
+  return r
+}
+
+const _createModelDefWithPrimaryKey = <T extends FunctionalModel>(
+  keyToProperty: ModelDefinition<T>
+): ModelDefinition<T> => {
+  return {
+    getPrimaryKeyName: () => 'id',
+    modelMethods: keyToProperty.modelMethods,
+    instanceMethods: keyToProperty.instanceMethods,
+    properties: {
+      id: UniqueId({ required: true }),
+      ...keyToProperty.properties,
+    },
+    modelValidators: keyToProperty.modelValidators,
+  }
+}
+
+const BaseModel = <T extends FunctionalModel>(
+  modelName: string,
+  modelDefinition: ModelDefinition<T>,
+  //keyToProperty: IModelDefinition2<T>,
+  options?: OptionalModelOptions
+) => {
+  /*
+   * This non-functional approach is specifically used to
+   * allow instances to be able to refer back to its parent without
+   * having to duplicate it for every instance.
+   * This is set at the very end and returned, so it can be referenced
+   * throughout instance methods.
+   */
+  // eslint-disable-next-line functional/no-let
+  let model: Nullable<Model<T>> = null
+  const theOptions = _convertOptions(options)
+  modelDefinition = !modelDefinition.getPrimaryKeyName
+    ? _createModelDefWithPrimaryKey(modelDefinition)
+    : modelDefinition
+
+  // @ts-ignore
+  const getPrimaryKeyName = () => modelDefinition.getPrimaryKeyName()
+  const getPrimaryKey = (t: ModelInstanceInputData<T>) =>
+    // @ts-ignore
+    t[getPrimaryKeyName()] as string
+
+  const create = (instanceValues: ModelInstanceInputData<T>) => {
+    // eslint-disable-next-line functional/no-let
+    let instance: Nullable<ModelInstance<T>> = null
+    const startingInternals: {
+      readonly get: PropertyGetters<T> & { readonly id: () => string }
+      readonly validators: PropertyValidators
+      readonly references: ReferenceFunctions
+    } = {
+      get: {} as PropertyGetters<T> & { readonly id: () => string },
+      validators: {},
+      references: {},
+    }
+    const loadedInternals = Object.entries(modelDefinition.properties).reduce(
+      (acc, [key, property]) => {
+        // @ts-ignore
+        const propertyGetter = property.createGetter(instanceValues[key])
+        // @ts-ignore
+        const propertyValidator = property.getValidator(propertyGetter)
+        const fleshedOutInstanceProperties = {
+          get: {
+            [key]: propertyGetter,
+          },
+          validators: {
+            [key]: propertyValidator,
+          },
+        }
+        const asReferenced = property as ReferencePropertyInstance<any>
+        const referencedProperty = asReferenced.getReferencedId
+          ? {
+              references: {
+                [key]: () =>
+                  asReferenced.getReferencedId(
+                    // @ts-ignore
+                    instanceValues[key] as ReferenceValueType<any>
+                  ),
+              },
+            }
+          : {}
+
+        return merge(acc, fleshedOutInstanceProperties, referencedProperty)
+      },
+      startingInternals
+    )
+    const methods = Object.entries(
+      modelDefinition.instanceMethods || {}
+    ).reduce((acc, [key, func]) => {
+      return merge(acc, {
+        [key]: (...args: readonly any[]) => {
+          return (func as ModelInstanceMethodTyped<T>)(
+            instance as ModelInstance<T>,
+            ...args
+          )
+        },
+      })
+    }, {}) as InstanceMethodGetters<T>
+
+    const getModel = () => model as Model<T>
+    const toObj = toJsonAble(loadedInternals.get)
+    const validate = (options = {}) => {
+      return createModelValidator(
+        loadedInternals.validators,
+        modelDefinition.modelValidators || []
+      )(instance as ModelInstance<T>, options)
+    }
+
+    instance = merge(loadedInternals, {
+      getModel,
+      toObj,
+      getPrimaryKey: () => getPrimaryKey(instanceValues),
+      getPrimaryKeyName,
+      validate,
+      methods,
+    })
+
+    if (theOptions.instanceCreatedCallback) {
+      const toCall = Array.isArray(theOptions.instanceCreatedCallback)
+        ? theOptions.instanceCreatedCallback
+        : [theOptions.instanceCreatedCallback]
+      toCall.map(func => func(instance as ModelInstance<T>))
+    }
+    return instance
+  }
+
+  const fleshedOutModelFunctions = Object.entries(
+    modelDefinition.modelMethods || {}
+  ).reduce((acc, [key, func]) => {
+    return merge(acc, {
+      [key]: (...args: readonly any[]) => {
+        return (func as ModelMethodTyped<T>)(model as Model<T>, ...args)
+      },
+    })
+  }, {}) as ModelMethodGetters<T>
+
+  // This sets the model that is used by the instances later.
+  model = merge(
+    {},
+    {
+      create,
+      getName: () => modelName,
+      getModelDefinition: () => modelDefinition,
+      getPrimaryKeyName,
+      getPrimaryKey,
+      methods: fleshedOutModelFunctions,
+    }
+  )
+  return model as Model<T>
+}
+
+export { BaseModel }

package/src/properties.ts

@@ -0,0 +1,375 @@
+import identity from 'lodash/identity'
+import merge from 'lodash/merge'
+import {
+  createPropertyValidator,
+  emptyValidator,
+  maxTextLength,
+  minTextLength,
+  minNumber,
+  maxNumber,
+  isType,
+  referenceTypeMatch,
+  meetsRegex,
+} from './validation'
+import { PROPERTY_TYPES } from './constants'
+import { lazyValue } from './lazy'
+import { createUuid } from './utils'
+import {
+  ReferenceValueType,
+  ModelInstance,
+  MaybeEmpty,
+  Nullable,
+  PrimaryKeyType,
+  Model,
+  PropertyInstance,
+  FunctionalType,
+  PropertyConfig,
+  ValueGetter,
+  MaybeFunction,
+  Arrayable,
+  PropertyValidatorComponent,
+  PropertyValidator,
+  ReferencePropertyInstance,
+  ModelInstanceInputData,
+  FunctionalModel,
+  JsonAble,
+} from './interfaces'
+
+const EMAIL_REGEX =
+  /[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?/u
+
+function _getValidatorFromConfigElseEmpty<T>(
+  input: T | undefined,
+  // eslint-disable-next-line no-unused-vars
+  validatorGetter: (t: T) => PropertyValidatorComponent
+) {
+  if (input !== undefined) {
+    const validator = validatorGetter(input)
+    return validator
+  }
+  return emptyValidator
+}
+
+const _mergeValidators = (
+  config: PropertyConfig | undefined,
+  validators: readonly PropertyValidatorComponent[]
+) => {
+  return [...validators, ...(config?.validators ? config.validators : [])]
+}
+
+function Property<T extends Arrayable<FunctionalType>>(
+  type: string,
+  config: PropertyConfig = {},
+  additionalMetadata = {}
+) {
+  if (!type && !config?.type) {
+    throw new Error(`Property type must be provided.`)
+  }
+  if (config?.type) {
+    type = config.type
+  }
+  const getConstantValue = () =>
+    (config?.value !== undefined ? config.value : undefined) as T
+  const getDefaultValue = () =>
+    (config?.defaultValue !== undefined ? config.defaultValue : undefined) as T
+  const getChoices = () => config?.choices || []
+  const lazyLoadMethod = config?.lazyLoadMethod || false
+  const valueSelector = config?.valueSelector || identity
+  if (typeof valueSelector !== 'function') {
+    throw new Error(`valueSelector must be a function`)
+  }
+
+  const r: PropertyInstance<T> = {
+    ...additionalMetadata,
+    getConfig: () => config || {},
+    getChoices,
+    getDefaultValue,
+    getConstantValue,
+    getPropertyType: () => type,
+    createGetter: (instanceValue: T): ValueGetter => {
+      const value = getConstantValue()
+      if (value !== undefined) {
+        return () => value
+      }
+      const defaultValue = getDefaultValue()
+      if (
+        defaultValue !== undefined &&
+        (instanceValue === null || instanceValue === undefined)
+      ) {
+        return () => defaultValue
+      }
+      const method = lazyLoadMethod
+        ? // eslint-disable-next-line no-unused-vars
+          (lazyValue(lazyLoadMethod) as (value: T) => Promise<T>)
+        : typeof instanceValue === 'function'
+        ? (instanceValue as () => T)
+        : () => instanceValue
+      return () => {
+        return valueSelector(method(instanceValue))
+      }
+    },
+    getValidator: valueGetter => {
+      const validator = createPropertyValidator(valueGetter, config)
+      const _propertyValidatorWrapper: PropertyValidator = async (
+        instance,
+        instanceData
+      ) => {
+        return validator(instance, instanceData)
+      }
+      return _propertyValidatorWrapper
+    },
+  }
+  return r
+}
+
+const DateProperty = (config: PropertyConfig = {}, additionalMetadata = {}) =>
+  Property<MaybeEmpty<Date>>(
+    PROPERTY_TYPES.DateProperty,
+    merge(
+      {
+        lazyLoadMethod: (value: Arrayable<FunctionalType>) => {
+          if (!value && config?.autoNow) {
+            return new Date()
+          }
+          return value
+        },
+      },
+      config
+    ),
+    additionalMetadata
+  )
+
+const ArrayProperty = <T extends FunctionalType>(
+  config = {},
+  additionalMetadata = {}
+) =>
+  Property<readonly T[]>(
+    PROPERTY_TYPES.ArrayProperty,
+    {
+      defaultValue: [],
+      ...config,
+      isArray: true,
+    },
+    additionalMetadata
+  )
+
+const ObjectProperty = (config = {}, additionalMetadata = {}) =>
+  Property<{ readonly [s: string]: JsonAble }>(
+    PROPERTY_TYPES.ObjectProperty,
+    merge(config, {
+      validators: _mergeValidators(config, [isType('object')]),
+    }),
+    additionalMetadata
+  )
+
+const TextProperty = (config: PropertyConfig = {}, additionalMetadata = {}) =>
+  Property<MaybeEmpty<string>>(
+    PROPERTY_TYPES.TextProperty,
+    merge(config, {
+      isString: true,
+      validators: _mergeValidators(config, [
+        _getValidatorFromConfigElseEmpty(config?.maxLength, (value: number) =>
+          maxTextLength(value)
+        ),
+        _getValidatorFromConfigElseEmpty(config?.minLength, (value: number) =>
+          minTextLength(value)
+        ),
+      ]),
+    }),
+    additionalMetadata
+  )
+
+const IntegerProperty = (
+  config: PropertyConfig = {},
+  additionalMetadata = {}
+) =>
+  Property<MaybeEmpty<number>>(
+    PROPERTY_TYPES.IntegerProperty,
+    merge(config, {
+      isInteger: true,
+      validators: _mergeValidators(config, [
+        _getValidatorFromConfigElseEmpty(config?.minValue, value =>
+          minNumber(value)
+        ),
+        _getValidatorFromConfigElseEmpty(config?.maxValue, value =>
+          maxNumber(value)
+        ),
+      ]),
+    }),
+    additionalMetadata
+  )
+
+const NumberProperty = (config: PropertyConfig = {}, additionalMetadata = {}) =>
+  Property<MaybeEmpty<number>>(
+    PROPERTY_TYPES.NumberProperty,
+    merge(config, {
+      isNumber: true,
+      validators: _mergeValidators(config, [
+        _getValidatorFromConfigElseEmpty(config?.minValue, value =>
+          minNumber(value)
+        ),
+        _getValidatorFromConfigElseEmpty(config?.maxValue, value =>
+          maxNumber(value)
+        ),
+      ]),
+    }),
+    additionalMetadata
+  )
+
+const ConstantValueProperty = (
+  value: string,
+  config: PropertyConfig = {},
+  additionalMetadata = {}
+) =>
+  TextProperty(
+    merge(config, {
+      type: PROPERTY_TYPES.ConstantValueProperty,
+      value,
+    }),
+    additionalMetadata
+  )
+
+const EmailProperty = (config: PropertyConfig = {}, additionalMetadata = {}) =>
+  TextProperty(
+    merge(config, {
+      type: PROPERTY_TYPES.EmailProperty,
+      validators: _mergeValidators(config, [meetsRegex(EMAIL_REGEX)]),
+    }),
+    additionalMetadata
+  )
+
+const BooleanProperty = (
+  config: PropertyConfig = {},
+  additionalMetadata = {}
+) =>
+  Property<MaybeEmpty<boolean>>(
+    PROPERTY_TYPES.BooleanProperty,
+    merge(config, {
+      isBoolean: true,
+    }),
+    additionalMetadata
+  )
+
+const UniqueId = (config: PropertyConfig = {}, additionalMetadata = {}) =>
+  Property<string>(
+    PROPERTY_TYPES.UniqueId,
+    merge(
+      {
+        lazyLoadMethod: (value: Arrayable<FunctionalType>) => {
+          if (!value) {
+            return createUuid()
+          }
+          return value
+        },
+      },
+      config
+    ),
+    additionalMetadata
+  )
+
+const ReferenceProperty = <T extends FunctionalModel>(
+  model: MaybeFunction<Model<T>>,
+  config: PropertyConfig = {},
+  additionalMetadata = {}
+) => {
+  if (!model) {
+    throw new Error('Must include the referenced model')
+  }
+
+  const _getModel = () => {
+    if (typeof model === 'function') {
+      return model()
+    }
+    return model
+  }
+
+  const validators = _mergeValidators(config, [referenceTypeMatch<T>(model)])
+
+  const _getId =
+    (instanceValues: ReferenceValueType<T>) =>
+    (): MaybeEmpty<PrimaryKeyType> => {
+      if (!instanceValues) {
+        return null
+      }
+      if (typeof instanceValues === 'number') {
+        return instanceValues
+      }
+      if (typeof instanceValues === 'string') {
+        return instanceValues
+      }
+      if ((instanceValues as ModelInstance<T>).getPrimaryKey) {
+        return (instanceValues as ModelInstance<T>).getPrimaryKey()
+      }
+
+      const theModel = _getModel()
+      const primaryKey = theModel.getPrimaryKeyName()
+
+      // @ts-ignore
+      return (instanceValues as ModelInstanceInputData<T>)[
+        primaryKey
+      ] as PrimaryKeyType
+    }
+
+  const lazyLoadMethod = async (instanceValues: ReferenceValueType<T>) => {
+    const valueIsModelInstance =
+      instanceValues && (instanceValues as ModelInstance<T>).getPrimaryKeyName
+    const _getInstanceReturn = (objToUse: ReferenceValueType<T>) => {
+      // We need to determine if the object we just go is an actual model instance to determine if we need to make one.
+      const objIsModelInstance =
+        instanceValues && (instanceValues as ModelInstance<T>).getPrimaryKeyName
+
+      const instance = objIsModelInstance
+        ? objToUse
+        : _getModel().create(objToUse as ModelInstanceInputData<T>)
+      return merge({}, instance, {
+        toObj: _getId(instanceValues),
+      })
+    }
+
+    if (valueIsModelInstance) {
+      return _getInstanceReturn(instanceValues)
+    }
+    if (config?.fetcher) {
+      const id = await _getId(instanceValues)()
+      const model = _getModel()
+      if (id !== null && id !== undefined) {
+        const obj = await config.fetcher(model, id)
+        return _getInstanceReturn(obj)
+      }
+      return null
+    }
+    return _getId(instanceValues)()
+  }
+
+  const p: ReferencePropertyInstance<T> = merge(
+    Property<ModelInstance<T> | T | MaybeEmpty<PrimaryKeyType>>(
+      PROPERTY_TYPES.ReferenceProperty,
+      merge({}, config, {
+        validators,
+        lazyLoadMethod,
+      }),
+      additionalMetadata
+    ),
+    {
+      getReferencedId: (instanceValues: ReferenceValueType<T>) =>
+        _getId(instanceValues)(),
+      getReferencedModel: _getModel,
+    }
+  )
+  return p
+}
+
+export {
+  Property,
+  UniqueId,
+  DateProperty,
+  ArrayProperty,
+  ReferenceProperty,
+  IntegerProperty,
+  TextProperty,
+  ConstantValueProperty,
+  NumberProperty,
+  ObjectProperty,
+  EmailProperty,
+  BooleanProperty,
+}

package/src/serialization.ts

@@ -0,0 +1,39 @@
+import merge from 'lodash/merge'
+import { PropertyGetters, JsonAble, toObj } from './interfaces'
+
+const _getValue = async (value: any): Promise<JsonAble> => {
+  if (value === undefined) {
+    return null
+  }
+  if (value === null) {
+    return null
+  }
+  const type = typeof value
+  const asFunction = value as Function
+  if (type === 'function') {
+    return _getValue(await asFunction())
+  }
+  // Nested Object
+  const asModel = value.toObj
+  if (asModel) {
+    return _getValue(await asModel())
+  }
+  // Dates
+  const asDate = value as Date
+  if (type === 'object' && asDate.toISOString) {
+    return _getValue(asDate.toISOString())
+  }
+  return value
+}
+
+const toJsonAble =
+  (keyToFunc: PropertyGetters<any>): toObj =>
+  async () => {
+    return Object.entries(keyToFunc).reduce(async (acc, [key, value]) => {
+      const realAcc = await acc
+      const trueValue = await _getValue(await value)
+      return merge(realAcc, { [key]: trueValue })
+    }, Promise.resolve({}))
+  }
+
+export { toJsonAble }

package/src/utils.ts

@@ -0,0 +1,42 @@
+// @ts-ignore
+import getRandomValuesFunc from 'get-random-values'
+
+const HEX = 16
+const FOUR = 4
+const FIFTEEN = 15
+
+const getRandomValues = (): Uint8Array => {
+  const array = new Uint8Array(1)
+  if (typeof window !== 'undefined') {
+    if (window.crypto) {
+      return window.crypto.getRandomValues(array)
+    }
+    // @ts-ignore
+    if (window.msCrypto) {
+      // @ts-ignore
+      return window.msCrypto.getRandomValues(array)
+    }
+  }
+
+  return getRandomValuesFunc(array)
+}
+
+const createUuid = (): string => {
+  // eslint-disable-next-line no-magic-numbers,require-unicode-regexp
+  // @ts-ignore
+  // eslint-disable-next-line no-magic-numbers,require-unicode-regexp
+  return ([1e7] + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, (c: any) => {
+    const value = getRandomValues()[0] & (FIFTEEN >> (c / FOUR))
+    return (c ^ value).toString(HEX)
+  })
+}
+
+const toTitleCase = (string: string) => {
+  return `${string.slice(0, 1).toUpperCase()}${string.slice(1)}`
+}
+
+const loweredTitleCase = (string: string) => {
+  return `${string.slice(0, 1).toLowerCase()}${string.slice(1)}`
+}
+
+export { loweredTitleCase, toTitleCase, createUuid }