functional-models 1.0.28 → 1.1.0

package/tsconfig.json

@@ -0,0 +1,100 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig.json to read more about this file */
+
+    /* Projects */
+    // "incremental": true,                              /* Enable incremental compilation */
+    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+    // "tsBuildInfoFile": "./",                          /* Specify the folder for .tsbuildinfo incremental compilation files. */
+    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects */
+    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
+    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
+
+    /* Language and Environment */
+    "target": "es6",                                     /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    "lib": ["es2021", "dom"],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
+    // "experimentalDecorators": true,                   /* Enable experimental support for TC39 stage 2 draft decorators. */
+    // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
+    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h' */
+    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using `jsx: react-jsx*`.` */
+    // "reactNamespace": "",                             /* Specify the object invoked for `createElement`. This only applies when targeting `react` JSX emit. */
+    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
+    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
+
+    /* Modules */
+    "module": "commonjs",                                /* Specify what module code is generated. */
+    //"rootDir": "./src" /* Specify the root folder within your source files. */,
+    // "moduleResolution": "node",                       /* Specify how TypeScript looks up a file from a given module specifier. */
+    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+    "rootDirs": ["./src", "./stepDefinitions"],                                   /* Allow multiple folders to be treated as one when resolving modules. */
+    // "typeRoots": [],                                  /* Specify multiple folders that act like `./node_modules/@types`. */
+    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
+    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
+    // "resolveJsonModule": true,                        /* Enable importing .json files */
+    // "noResolve": true,                                /* Disallow `import`s, `require`s or `<reference>`s from expanding the number of files TypeScript should add to a project. */
+
+    /* JavaScript Support */
+    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the `checkJS` option to get errors from these files. */
+    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from `node_modules`. Only applicable with `allowJs`. */
+
+    /* Emit */
+    "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+    // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
+    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+     "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
+    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If `declaration` is true, also designates a file that bundles all .d.ts output. */
+    "outDir": "./dist" /* Specify an output folder for all emitted files. */,
+    // "removeComments": true,                           /* Disable emitting comments. */
+    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
+    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+    // "importsNotUsedAsValues": "remove",               /* Specify emit/checking behavior for imports that are only used for types */
+    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
+    // "stripInternal": true,                            /* Disable emitting declarations that have `@internal` in their JSDoc comments. */
+    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like `__extends` in compiled output. */
+    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
+    // "preserveConstEnums": true,                       /* Disable erasing `const enum` declarations in generated code. */
+    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
+
+    /* Interop Constraints */
+    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
+    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables `allowSyntheticDefaultImports` for type compatibility. */
+    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
+
+    /* Type Checking */
+    "strict": true,                                      /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied `any` type.. */
+    // "strictNullChecks": true,                         /* When type checking, take into account `null` and `undefined`. */
+    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+    // "strictBindCallApply": true,                      /* Check that the arguments for `bind`, `call`, and `apply` methods match the original function. */
+    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+    // "noImplicitThis": true,                           /* Enable error reporting when `this` is given the type `any`. */
+    // "useUnknownInCatchVariables": true,               /* Type catch clause variables as 'unknown' instead of 'any'. */
+    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
+    // "noUnusedLocals": true,                           /* Enable error reporting when a local variables aren't read. */
+    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read */
+    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
+    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+    // "noUncheckedIndexedAccess": true,                 /* Include 'undefined' in index signature results */
+    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type */
+    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
+    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
+
+    /* Completeness */
+    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
+    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
+  }
+}

package/src/constants.js

@@ -1,19 +0,0 @@
-const { getObjToArray } = require('./utils')
-
-const PROPERTY_TYPES = getObjToArray([
-  'UniqueId',
-  'DateProperty',
-  'ArrayProperty',
-  'ReferenceProperty',
-  'IntegerProperty',
-  'TextProperty',
-  'ConstantValueProperty',
-  'NumberProperty',
-  'ObjectProperty',
-  'EmailProperty',
-  'BooleanProperty',
-])
-
-module.exports = {
-  PROPERTY_TYPES,
-}

package/src/functions.js

@@ -1,7 +0,0 @@
-const Function = method => wrapped => () => {
-  return method(wrapped)
-}
-
-module.exports = {
-  Function,
-}

package/src/index.js

@@ -1,10 +0,0 @@
-module.exports = {
-  constants: require('./constants'),
-  ...require('./properties'),
-  ...require('./models'),
-  ...require('./functions'),
-  errors: require('./errors'),
-  validation: require('./validation'),
-  serialization: require('./serialization'),
-  utils: require('./utils'),
-}

package/src/models.js

@@ -1,152 +0,0 @@
-const merge = require('lodash/merge')
-const get = require('lodash/get')
-const { toObj } = require('./serialization')
-const { createModelValidator } = require('./validation')
-const { UniqueId, createPropertyTitle } = require('./properties')
-
-const MODEL_DEF_KEYS = ['meta', 'functions']
-
-const Model = (
-  modelName,
-  keyToProperty,
-  {
-    primaryKey = 'id',
-    getPrimaryKeyProperty = () => UniqueId({ required: true }),
-    instanceCreatedCallback = null,
-    modelFunctions = {},
-    instanceFunctions = {},
-    modelValidators = [],
-  } = {}
-) => {
-  /*
-   * 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 = null
-  keyToProperty = {
-    // this key exists over keyToProperty, so it can be overrided if desired.
-    [primaryKey]: getPrimaryKeyProperty(),
-    ...keyToProperty,
-  }
-  const instanceProperties = Object.entries(keyToProperty).filter(
-    ([key, _]) => MODEL_DEF_KEYS.includes(key) === false
-  )
-  const specialProperties1 = Object.entries(keyToProperty).filter(([key, _]) =>
-    MODEL_DEF_KEYS.includes(key)
-  )
-  const properties = instanceProperties.reduce((acc, [key, property]) => {
-    return merge(acc, { [key]: property })
-  }, {})
-  const specialProperties = specialProperties1.reduce(
-    (acc, [key, property]) => {
-      return merge(acc, { [key]: property })
-    },
-    {}
-  )
-
-  const create = (instanceValues = {}) => {
-    // eslint-disable-next-line functional/no-let
-    let instance = null
-    const specialInstanceProperties1 = MODEL_DEF_KEYS.reduce((acc, key) => {
-      if (key in instanceValues) {
-        return { ...acc, [key]: instanceValues[key] }
-      }
-      return acc
-    }, {})
-    const loadedInternals = instanceProperties.reduce(
-      (acc, [key, property]) => {
-        const propertyGetter = property.createGetter(instanceValues[key])
-        const propertyValidator = property.getValidator(propertyGetter)
-        const getPropertyKey = createPropertyTitle(key)
-        const fleshedOutInstanceProperties = {
-          [getPropertyKey]: propertyGetter,
-          functions: {
-            getters: {
-              [key]:  propertyGetter,
-            },
-            validators: {
-              [key]: propertyValidator,
-            },
-          },
-        }
-        const referenceProperties = get(property, 'meta.getReferencedId')
-          ? {
-            meta: {
-              references: {
-                [createPropertyTitle(`${key}Id`)]: () => property.meta.getReferencedId(instanceValues[key])
-              }
-            }
-          }
-          : {}
-        return merge(acc, fleshedOutInstanceProperties, referenceProperties)
-      },
-      {}
-    )
-    const frameworkProperties = {
-      meta: {
-        getModel: () => model,
-      },
-      functions: {
-        toObj: toObj(loadedInternals),
-        getPrimaryKey: loadedInternals[createPropertyTitle(primaryKey)],
-        validate: (options={}) => {
-          return createModelValidator(
-            loadedInternals,
-            modelValidators
-          )(instance, options)
-        },
-      },
-    }
-    const fleshedOutInstanceFunctions = Object.entries(
-      instanceFunctions
-    ).reduce((acc, [key, func]) => {
-      return merge(acc, {
-        functions: {
-          [key]: (...args) => {
-            return func(...args, instance)
-          },
-        },
-      })
-    }, {})
-    instance = merge(
-      {},
-      loadedInternals,
-      specialProperties,
-      fleshedOutInstanceFunctions,
-      frameworkProperties,
-      specialInstanceProperties1
-    )
-    if (instanceCreatedCallback) {
-      instanceCreatedCallback(instance)
-    }
-    return instance
-  }
-
-  const fleshedOutModelFunctions = Object.entries(modelFunctions).reduce(
-    (acc, [key, func]) => {
-      return merge(acc, {
-        [key]: (...args) => {
-          return func(model)(...args)
-        },
-      })
-    },
-    {}
-  )
-
-  // This sets the model that is used by the instances later.
-  model = merge({}, fleshedOutModelFunctions, {
-    create,
-    getName: () => modelName,
-    getProperties: () => properties,
-    getPrimaryKeyName: () => primaryKey,
-  })
-  return model
-}
-
-module.exports = {
-  Model,
-}

package/src/properties.js

@@ -1,313 +0,0 @@
-const identity = require('lodash/identity')
-const get = require('lodash/get')
-const isFunction = require('lodash/isFunction')
-const merge = require('lodash/merge')
-const {
-  createPropertyValidator,
-  emptyValidator,
-  maxTextLength,
-  minTextLength,
-  minNumber,
-  maxNumber,
-  isType,
-  referenceTypeMatch,
-  meetsRegex,
-} = require('./validation')
-const { PROPERTY_TYPES } = require('./constants')
-const { lazyValue } = require('./lazy')
-const { toTitleCase, createUuid } = require('./utils')
-
-const createPropertyTitle = key => {
-  const goodName = toTitleCase(key)
-  return `get${goodName}`
-}
-
-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
-
-const _getValidatorFromConfigElseEmpty = (config, key, validatorGetter) => {
-  if (key in config) {
-    return validatorGetter(config[key])
-  }
-  return emptyValidator
-}
-
-const _mergeValidators = (config, validators) => {
-  return [...validators, ...(config.validators ? config.validators : [])]
-}
-
-const Property = (type, config = {}, 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
-  const getDefaultValue = () => config.defaultValue !== undefined ? config.defaultValue : undefined
-  const getChoices = () => config.choices ? config.choices : []
-  const lazyLoadMethod = config.lazyLoadMethod || false
-  const valueSelector = config.valueSelector || identity
-  if (typeof valueSelector !== 'function') {
-    throw new Error(`valueSelector must be a function`)
-  }
-
-
-  return {
-    ...additionalMetadata,
-    getConfig: () => config,
-    getChoices,
-    getDefaultValue,
-    getConstantValue,
-    getPropertyType: () => type,
-    createGetter: instanceValue => {
-      const value = getConstantValue()
-      if (value !== undefined) {
-        return () => value
-      }
-      const defaultValue = getDefaultValue()
-      if (
-        defaultValue !== undefined &&
-        (instanceValue === null || instanceValue === undefined)
-      ) {
-        return () => defaultValue
-      }
-      const method = lazyLoadMethod
-        ? lazyValue(lazyLoadMethod)
-        : typeof instanceValue === 'function'
-        ? instanceValue
-        : () => instanceValue
-      return async () => {
-        return valueSelector(await method(instanceValue))
-      }
-    },
-    getValidator: valueGetter => {
-      const validator = createPropertyValidator(config)
-      const _propertyValidatorWrapper = async (instance, instanceData, options={}) => {
-        return validator(await valueGetter(), instance, instanceData, options)
-      }
-      return _propertyValidatorWrapper
-    },
-  }
-}
-
-const DateProperty = (config = {}, additionalMetadata={}) => Property(PROPERTY_TYPES.DateProperty, {
-  ...config,
-  lazyLoadMethod: value => {
-    if (!value && config.autoNow) {
-      return new Date()
-    }
-    return value
-  },
-}, additionalMetadata)
-
-const ReferenceProperty = (model, config = {}, additionalMetadata={}) => {
-  if (!model) {
-    throw new Error('Must include the referenced model')
-  }
-
-  const _getModel = () => {
-    if (isFunction(model)) {
-      return model()
-    }
-    return model
-  }
-
-  const validators = _mergeValidators(config, [referenceTypeMatch(model)])
-
-  const _getId = (instanceValues) => () => {
-    if (!instanceValues) {
-      return null
-    }
-    const theModel = _getModel()
-    const primaryKey = theModel.getPrimaryKeyName()
-    if (instanceValues[primaryKey]) {
-      return instanceValues[primaryKey]
-    }
-    const primaryKeyFunc = get(instanceValues, 'functions.getPrimaryKey')
-    if (primaryKeyFunc) {
-      return primaryKeyFunc()
-    }
-    return instanceValues
-  }
-
-  const lazyLoadMethod = async instanceValues => {
-
-    const valueIsModelInstance =
-      Boolean(instanceValues) && Boolean(instanceValues.functions)
-
-    const _getInstanceReturn = objToUse => {
-      // 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 =
-        Boolean(objToUse) && Boolean(objToUse.functions)
-      const instance = objIsModelInstance
-        ? objToUse
-        : _getModel().create(objToUse)
-      return merge({}, instance, {
-        functions: {
-          toObj: _getId(instanceValues),
-        },
-      })
-    }
-
-    if (valueIsModelInstance) {
-      return _getInstanceReturn(instanceValues)
-    }
-    if (config.fetcher) {
-      const id = await _getId(instanceValues)()
-      const model = _getModel()
-      const obj = await config.fetcher(model, id)
-      return _getInstanceReturn(obj)
-    }
-    return _getId(instanceValues)()
-  }
-
-  return Property(
-    PROPERTY_TYPES.ReferenceProperty,
-    merge({}, config, {
-      validators,
-      lazyLoadMethod,
-    }),
-    {
-      ...additionalMetadata,
-      meta: {
-        getReferencedId: (instanceValues) => _getId(instanceValues)(),
-        getReferencedModel: _getModel,
-      },
-    }
-  )
-}
-
-const ArrayProperty = (config = {}, additionalMetadata={}) =>
-  Property(
-    PROPERTY_TYPES.ArrayProperty,
-    {
-    defaultValue: [],
-    ...config,
-    isArray: true,
-  }, additionalMetadata)
-
-const ObjectProperty = (config = {}, additionalMetadata={}) =>
-  Property(
-    PROPERTY_TYPES.ObjectProperty,
-    merge(config, {
-      validators: _mergeValidators(config, [isType('object')]),
-    }),
-    additionalMetadata
-  )
-
-const TextProperty = (config = {}, additionalMetadata={} ) =>
-  Property(
-    PROPERTY_TYPES.TextProperty,
-    merge(config, {
-      isString: true,
-      validators: _mergeValidators(config, [
-        _getValidatorFromConfigElseEmpty(config, 'maxLength', value =>
-          maxTextLength(value)
-        ),
-        _getValidatorFromConfigElseEmpty(config, 'minLength', value =>
-          minTextLength(value)
-        ),
-      ]),
-    }),
-    additionalMetadata
-  )
-
-const IntegerProperty = (config = {}, additionalMetadata={}) =>
-  Property(
-    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 = {}, additionalMetadata={}) =>
-  Property(
-    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, config = {}, additionalMetadata={}) =>
-  TextProperty(
-    merge(config, {
-      type: PROPERTY_TYPES.ConstantValueProperty,
-      value,
-    }),
-    additionalMetadata
-  )
-
-const EmailProperty = (config = {}, additionalMetadata={}) =>
-  TextProperty(
-    merge(config, {
-      type: PROPERTY_TYPES.EmailProperty,
-      validators: _mergeValidators(config, [meetsRegex(EMAIL_REGEX)]),
-    }),
-    additionalMetadata
-  )
-
-const BooleanProperty = (config = {}, additionalMetadata={}) => Property(
-  PROPERTY_TYPES.BooleanProperty,
-  merge(config, {
-      isBoolean: true,
-      validators: _mergeValidators(config, [
-        _getValidatorFromConfigElseEmpty(config, 'minValue', value =>
-          minNumber(value)
-        ),
-        _getValidatorFromConfigElseEmpty(config, 'maxValue', value =>
-          maxNumber(value)
-        ),
-      ]),
-    }),
-    additionalMetadata
-)
-
-const UniqueId = (config = {}, additionalMetadata={}) =>
-  Property(
-    PROPERTY_TYPES.UniqueId,
-    {
-    ...config,
-    lazyLoadMethod: value => {
-      if (!value) {
-        return createUuid()
-      }
-      return value
-    },
-  }, additionalMetadata)
-
-
-
-module.exports = {
-  Property,
-  UniqueId,
-  DateProperty,
-  ArrayProperty,
-  ReferenceProperty,
-  IntegerProperty,
-  TextProperty,
-  ConstantValueProperty,
-  NumberProperty,
-  ObjectProperty,
-  EmailProperty,
-  BooleanProperty,
-  createPropertyTitle,
-}

package/src/serialization.js

@@ -1,50 +0,0 @@
-const { loweredTitleCase } = require('./utils')
-
-const SIZE_OF_GET = 'get'.length
-const IGNORABLE_KEYS = ['meta', 'functions']
-
-const _getValue = async value => {
-  if (value === undefined) {
-    return null
-  }
-  if (value === null) {
-    return null
-  }
-  const type = typeof value
-  if (type === 'function') {
-    return _getValue(await value())
-  }
-  // Nested Json
-  if (type === 'object' && value.functions && value.functions.toObj) {
-    return _getValue(await value.functions.toObj())
-  }
-  // Dates
-  if (type === 'object' && value.toISOString) {
-    return _getValue(value.toISOString())
-  }
-  return value
-}
-
-const _getKey = key => {
-  return key.startsWith('get') ? loweredTitleCase(key.slice(SIZE_OF_GET)) : key
-}
-
-const _shouldIgnoreKey = key => {
-  return IGNORABLE_KEYS.includes(key)
-}
-
-const toObj = keyToFunc => async () => {
-  return Object.entries(keyToFunc).reduce(async (acc, [key, value]) => {
-    const realAcc = await acc
-    if (_shouldIgnoreKey(key)) {
-      return realAcc
-    }
-    const keyToUse = _getKey(key)
-    const trueValue = await _getValue(value)
-    return { ...realAcc, [keyToUse]: trueValue }
-  }, Promise.resolve({}))
-}
-
-module.exports = {
-  toObj,
-}