@based/schema 2.0.0 → 2.2.0

package/src/types.ts

@@ -1,365 +0,0 @@
-import type { Language } from './languages'
-import type { PartialDeep, SetOptional } from 'type-fest'
-import { ParseError } from './error'
-import { ArgsClass, Path } from './walker'
-
-// Schema type
-// inspiration from https://json-schema.org/understanding-json-schema/index.html
-// but added a few extra types
-//   reference
-//   references
-//   set
-//   record
-
-// https://json-schema.org/learn/examples/geographical-location.schema.json
-
-// contentSchema can be used for JSON types as well
-// contentSchema can be used for reference / refrences
-
-// TODO parser / validator / parseOut / parseIn (parsIn after validator)
-
-// for refs etc check https://json-schema.org/understanding-json-schema/structuring.html#defs
-
-export type AllowedTypes = (string | { type?: string; $filter: any | any[] })[]
-
-export type BasedSchemaFieldType =
-  | 'array'
-  | 'object'
-  | 'record'
-  | 'set'
-  | 'string'
-  | 'boolean'
-  | 'number'
-  | 'json'
-  | 'integer'
-  | 'timestamp'
-  | 'reference'
-  | 'references'
-  | 'text'
-  | 'cardinality'
-
-export const isCollection = (type: string): boolean => {
-  return type === 'array' || type === 'object' || type === 'record'
-}
-
-export type BasedSchemaPattern = string // RE ^[A-Za-z_][A-Za-z0-9_]*$
-
-export type BasedSchemaLanguage = Language // fix
-
-export type BasedSchemaTypePrefix = string // fix
-
-// Some examples
-export type BasedSchemaContentMediaType =
-  | 'text/html'
-  | 'text/plain'
-  | 'text/markdown'
-  | 'image/png'
-  | 'image/jpeg'
-  | 'video/mp4'
-  | 'image/*'
-  | 'video/*'
-  | 'audio/*'
-  | '*/*'
-  | `${string}/${string}`
-
-export type BasedSchemaFieldShared = {
-  hooks?:
-    | { interval?: number; hook: string }
-    | { interval?: number; hook: string }[]
-  type?: BasedSchemaFieldType
-  $id?: string
-  $schema?: string
-  isRequired?: boolean
-  title?: string
-  description?: string
-  index?: number // Determines the order of fields
-  readOnly?: boolean
-  writeOnly?: boolean
-  $comment?: string
-  examples?: any[] // <--- make this generic
-  default?: any // <-- make this generic
-  // extra thing by us allow users to overwrite entire validations
-  customValidator?: (
-    value: any,
-    path: (number | string)[],
-    target: BasedSetTarget
-  ) => Promise<boolean>
-  $defs?: { [key: string]: BasedSchemaField }
-  // TODO: This is an option. Should be in another place
-  $delete?: boolean
-}
-
-// -------------- Primitive ---------------
-export type BasedSchemaStringShared = {
-  minLength?: number
-  maxLength?: number
-  contentMediaEncoding?: string // base64
-  contentMediaType?: BasedSchemaContentMediaType // 'image/*'
-  pattern?: BasedSchemaPattern // TODO: does not exist
-  format?:
-    | 'email'
-    | 'URL'
-    | 'MACAddress'
-    | 'IP'
-    | 'IPRange'
-    | 'FQDN'
-    | 'IBAN'
-    | 'BIC'
-    | 'alpha'
-    | 'alphaLocales'
-    | 'alphanumeric'
-    | 'alphanumericLocales'
-    | 'passportNumber'
-    | 'port'
-    | 'lowercase'
-    | 'uppercase'
-    | 'ascii'
-    | 'semVer'
-    | 'surrogatePair'
-    | 'IMEI'
-    | 'hexadecimal'
-    | 'octal'
-    | 'hexColor'
-    | 'rgbColor'
-    | 'HSL'
-    | 'ISRC'
-    | 'MD5'
-    | 'JWT'
-    | 'UUID'
-    | 'luhnNumber'
-    | 'creditCard'
-    | 'identityCard'
-    | 'EAN'
-    | 'ISIN'
-    | 'ISBN'
-    | 'ISSN'
-    | 'mobilePhone'
-    | 'mobilePhoneLocales'
-    | 'postalCode'
-    | 'postalCodeLocales'
-    | 'ethereumAddress'
-    | 'currency'
-    | 'btcAddress'
-    | 'ISO6391'
-    | 'ISO8601'
-    | 'RFC3339'
-    | 'ISO31661Alpha2'
-    | 'ISO31661Alpha3'
-    | 'ISO4217'
-    | 'base32'
-    | 'base58'
-    | 'base64'
-    | 'dataURI'
-    | 'magnetURI'
-    | 'mimeType'
-    | 'latLong'
-    | 'slug'
-    | 'strongPassword'
-    | 'taxID'
-    | 'licensePlate'
-    | 'VAT'
-}
-
-export type BasedSchemaFieldString = {
-  type: 'string'
-
-  // maybe add some more? e.g. phone
-} & BasedSchemaFieldShared &
-  BasedSchemaStringShared
-
-export type BasedSchemaFieldEnum = {
-  enum: any[]
-} & BasedSchemaFieldShared
-
-// TODO: check if we want this later
-// export type BasedSchemaFieldConst = {
-//   const: any
-// } & BasedSchemaFieldShared
-
-type NumberDefaults = {
-  multipleOf?: number
-  minimum?: number
-  maximum?: number
-  exclusiveMaximum?: boolean
-  exclusiveMinimum?: boolean
-}
-
-export type BasedSchemaFieldNumber = NumberDefaults & {
-  type: 'number'
-}
-
-export type BasedSchemaFieldCardinality = {
-  type: 'cardinality'
-}
-
-export type BasedSchemaFieldInteger = NumberDefaults & {
-  type: 'integer'
-} & BasedSchemaFieldShared
-
-export type BasedSchemaFieldTimeStamp = NumberDefaults & {
-  type: 'timestamp'
-} & BasedSchemaFieldShared
-
-export type BasedSchemaFieldBoolean = {
-  type: 'boolean'
-} & BasedSchemaFieldShared
-
-// Can support full json SCHEMA validation for this
-export type BasedSchemaFieldJSON = {
-  type: 'json'
-} & BasedSchemaFieldShared
-
-export type BasedSchemaFieldPrimitive =
-  | BasedSchemaFieldString
-  | BasedSchemaFieldNumber
-  | BasedSchemaFieldInteger
-  | BasedSchemaFieldTimeStamp
-  | BasedSchemaFieldJSON
-  | BasedSchemaFieldBoolean
-  | BasedSchemaFieldEnum
-  | BasedSchemaFieldShared
-
-// -------------- Enumerable ---------------
-export type BasedSchemaFieldText = {
-  type: 'text'
-  required?: BasedSchemaLanguage[]
-} & BasedSchemaFieldShared &
-  BasedSchemaStringShared
-
-export type BasedSchemaFieldObject = {
-  type: 'object'
-  properties: {
-    [name: string]: BasedSchemaField
-  }
-  required?: string[]
-} & BasedSchemaFieldShared
-
-export type BasedSchemaFieldRecord = {
-  type: 'record'
-  values: BasedSchemaField
-} & BasedSchemaFieldShared
-
-export type BasedSchemaFieldArray = {
-  type: 'array'
-  values: BasedSchemaField
-} & BasedSchemaFieldShared
-
-export type BasedSchemaFieldSet = {
-  type: 'set'
-  items: BasedSchemaFieldPrimitive
-} & BasedSchemaFieldShared
-
-export type BasedSchemaFieldEnumerable =
-  | BasedSchemaFieldText
-  | BasedSchemaFieldObject
-  | BasedSchemaFieldRecord
-  | BasedSchemaFieldArray
-  | BasedSchemaFieldSet
-
-// -------------- Reference ---------------
-export type BasedSchemaFieldReference = {
-  type: 'reference'
-  bidirectional?: {
-    fromField: string
-  }
-  // TODO: selva filters { $operator: 'includes', $value: 'image/', $field: 'mimeType' }
-  allowedTypes?: AllowedTypes
-} & BasedSchemaFieldShared
-
-// make extra package called based db - query (maybe in based-db)
-export type BasedSchemaFieldReferences = {
-  type: 'references'
-  bidirectional?: {
-    fromField: string
-  }
-  allowedTypes?: AllowedTypes
-} & BasedSchemaFieldShared
-
-// return type can be typed - sort of
-export type BasedSchemaField =
-  | BasedSchemaFieldEnumerable
-  | BasedSchemaFieldPrimitive
-  | BasedSchemaFieldReference
-  | BasedSchemaFieldReferences
-  | BasedSchemaFieldCardinality
-  | {
-      type?: BasedSchemaFieldType
-      isRequired?: boolean // our own
-      $ref: string // to mimic json schema will just load it in place (so only for setting)
-    }
-
-export type BasedSchemaFields = {
-  enum: BasedSchemaFieldEnum
-  array: BasedSchemaFieldArray
-  object: BasedSchemaFieldObject
-  set: BasedSchemaFieldSet
-  record: BasedSchemaFieldRecord
-  string: BasedSchemaFieldString
-  boolean: BasedSchemaFieldBoolean
-  number: BasedSchemaFieldNumber
-  json: BasedSchemaFieldJSON
-  integer: BasedSchemaFieldInteger
-  timestamp: BasedSchemaFieldTimeStamp
-  reference: BasedSchemaFieldReference
-  references: BasedSchemaFieldReferences
-  text: BasedSchemaFieldText
-  cardinality: BasedSchemaFieldCardinality
-}
-
-export type BasedSchemaType = {
-  fields: {
-    [name: string]: BasedSchemaField
-  }
-  title?: string
-  description?: string
-  prefix?: BasedSchemaTypePrefix
-  examples?: any[]
-  required?: string[]
-  $defs?: { [key: string]: BasedSchemaField }
-  // TODO: This is an option. Should be in another place
-  $delete?: boolean
-}
-
-// this is the return value,, optional for insert
-export type BasedSchema = {
-  language: BasedSchemaLanguage
-  translations?: BasedSchemaLanguage[]
-  languageFallbacks?: Partial<
-    Record<BasedSchemaLanguage, BasedSchemaLanguage[]>
-  >
-  root: BasedSchemaType
-  // in our setup this is used as top level /$defs/[name]/
-  // in our setup this is used as top level /types/[name]/$defs/[name]
-  // #/$defs/name
-  $defs: { [name: string]: BasedSchemaField }
-  types: {
-    [type: string]: BasedSchemaType
-  }
-  prefixToTypeMapping: {
-    [prefix: string]: string
-  }
-}
-
-export type BasedSchemaTypePartial = PartialDeep<BasedSchemaType>
-
-export type BasedSchemaFieldPartial = PartialDeep<BasedSchemaField>
-
-export type BasedSchemaPartial = PartialDeep<BasedSchema>
-
-export type BasedSetTarget = {
-  type: string
-  $alias?: string
-  $id?: string
-  schema: BasedSchema
-  $merge?: boolean
-  $language?: BasedSchemaLanguage
-  required: (number | string)[][]
-  collected: BasedSchemaCollectProps[]
-  errors: { code: ParseError; path: Path }[]
-}
-
-export type BasedSchemaCollectProps = ArgsClass<BasedSetTarget> & {
-  root: ArgsClass<BasedSetTarget> & {
-    typeSchema: BasedSchemaType
-  }
-}

package/src/updateSchema.ts

@@ -1,18 +0,0 @@
-import { BasedSchema, BasedSchemaPartial } from './types'
-
-export const updateSchema = async (
-  newSchema: BasedSchemaPartial,
-  oldSchema: BasedSchema = {
-    $defs: {},
-    types: {},
-    language: 'en',
-    root: { fields: {} },
-    prefixToTypeMapping: {},
-  }
-): Promise<BasedSchema> => {
-  // add sha
-
-  // put isRequired on the new schema in REQUIRED arrays
-
-  return oldSchema
-}

package/src/validateSchema.ts

@@ -1,64 +0,0 @@
-import {
-  BasedSchemaPartial,
-  BasedSchemaFieldPartial,
-  BasedSchemaTypePartial,
-} from './types'
-
-// gaurd in the schema for refs in arrays
-
-export const validateType = (
-  fromSchema: BasedSchemaPartial,
-  typeName: string,
-  type: BasedSchemaTypePartial
-) => {
-  if (
-    type.prefix &&
-    (typeof type.prefix !== 'string' || type.prefix.length !== 2)
-  ) {
-    throw new Error(
-      `Incorrect prefix "${type.prefix}" for type "${typeName}" has to be a string of 2 alphanumerical characters e.g. "Az", "ab", "cc", "10"`
-    )
-  }
-}
-
-export const validateField = (
-  fromSchema: BasedSchemaPartial,
-  path: string[],
-  field: BasedSchemaFieldPartial
-) => {
-  //
-}
-
-export const validateSchema = (
-  schema: BasedSchemaPartial
-): BasedSchemaPartial => {
-  // rewrite schema things like required / required: []
-
-  if (typeof schema !== 'object') {
-    throw new Error('Schema is not an object')
-  }
-
-  if (schema.language && typeof schema.language !== 'string') {
-    throw new Error('Language must be a string')
-  }
-
-  if (schema.translations && !Array.isArray(schema.translations)) {
-    throw new Error('Translations needs to be an array')
-  }
-
-  if (schema.$defs) {
-    // first defs ofc
-  }
-
-  if (schema.root) {
-    validateType(schema, 'root', schema.root)
-  }
-
-  if (schema.types) {
-    for (const type in schema.types) {
-      validateType(schema, type, schema.types[type])
-    }
-  }
-
-  return schema
-}

package/src/walker/args.ts

@@ -1,209 +0,0 @@
-import { BasedSchema } from '../types'
-import { BasedSchemaType, BasedSchemaFields } from '../types'
-import { ArgsOpts, Path, Opts, Stopped, Collect } from './types'
-import { parse } from './parse'
-import { ParseError } from '../error'
-import { deepEqual } from '@saulx/utils'
-
-let id = 0
-
-export class ArgsClass<
-  T,
-  K extends keyof BasedSchemaFields = keyof BasedSchemaFields
-> {
-  errors: any[]
-
-  id: number
-
-  prev: ArgsClass<T, K>
-
-  root: ArgsClass<T, K> // getter
-
-  // only on root
-  _opts: Opts<T>
-
-  _target: T
-
-  _stopObject?: boolean
-
-  _schema: BasedSchema
-
-  parseTopLevel?: boolean
-
-  _collectOverride: Collect<T>
-
-  fieldSchema?: BasedSchemaFields[K]
-
-  typeSchema?: BasedSchemaType
-
-  path: Path
-
-  skipCollection: boolean
-
-  value: any
-
-  stopped: Stopped | void
-
-  fromBackTrack: any[]
-
-  collectedCommands: any[]
-
-  constructor(opts: ArgsOpts<T, K>, prev?: ArgsClass<T, K>) {
-    this.id = ++id
-    this.fromBackTrack = []
-    this.collectedCommands = []
-    if (opts.prev) {
-      prev = opts.prev
-    }
-    if (opts.parseTopLevel) {
-      this.parseTopLevel = opts.parseTopLevel
-    }
-    if (prev) {
-      this.prev = prev
-      this.root = prev.root
-      this.fieldSchema = prev.fieldSchema
-    }
-    if (opts.path) {
-      this.path = opts.path
-    } else if (prev && opts.key !== undefined) {
-      this.path = [...prev.path, opts.key]
-    } else if (opts && prev) {
-      this.path = prev.path
-    } else {
-      this.path = []
-    }
-    this.value = opts.value
-    if (opts.fieldSchema) {
-      // @ts-ignore K is too loose
-      this.fieldSchema = opts.fieldSchema
-    }
-    if (opts.typeSchema) {
-      this.typeSchema = opts.typeSchema
-    }
-    if (opts.target) {
-      this._target = opts.target
-    }
-    if (opts.collect) {
-      this._collectOverride = opts.collect
-    } else if (prev?._collectOverride) {
-      this._collectOverride = prev._collectOverride
-    }
-
-    if (opts.skipCollection) {
-      this.skipCollection = opts.skipCollection
-    } else if (prev?.skipCollection) {
-      this.skipCollection = true
-    }
-  }
-
-  get schema(): BasedSchema {
-    if (this._schema) {
-      return this.schema
-    }
-    return this.root._schema
-  }
-
-  get key(): number | string {
-    return this.path[this.path.length - 1] ?? ''
-  }
-
-  get target(): T {
-    if (this._target) {
-      return this._target
-    }
-    let p = this.prev
-    while (p) {
-      if (p._target) {
-        return p._target
-      }
-      p = p.prev
-    }
-  }
-
-  stop(onllyStopFieldSchemaParser?: boolean) {
-    const target = this
-    if (onllyStopFieldSchemaParser) {
-      target.stopped = Stopped.onlyStopFieldParser
-    } else {
-      target.stopped = Stopped.stopAll
-    }
-  }
-
-  create(opts?: ArgsOpts<T>): ArgsClass<T> {
-    const newArgs = new ArgsClass(opts, this)
-    if (this._collectOverride && !opts.collect) {
-      newArgs._collectOverride = this._collectOverride
-    }
-    if (this.skipCollection && opts.skipCollection !== false) {
-      newArgs.skipCollection = this.skipCollection
-    }
-    if (!('value' in opts)) {
-      newArgs.value = this.value
-    }
-    return newArgs
-  }
-
-  async parse(opts?: ArgsOpts<T>): Promise<ArgsClass<T> | void> {
-    if (!opts) {
-      return parse(this)
-    } else {
-      const newArgs = new ArgsClass(opts, this)
-
-      if (newArgs.value === undefined) {
-        newArgs.value = this.value
-      }
-
-      return newArgs.parse()
-    }
-  }
-
-  getTopPaths(): Path[] {
-    let argPath = []
-    let p = this
-    while (p) {
-      argPath.unshift({ path: p.path, id: p.id })
-      // @ts-ignore
-      p = p.prev
-    }
-    return argPath
-  }
-
-  getBackTrackTarget(): ArgsClass<T> {
-    let p: ArgsClass<T> = this
-    while (p) {
-      if (p.prev) {
-        if (deepEqual(p.prev.path, p.path)) {
-          p = p.prev
-        } else {
-          p = p.prev
-          break
-        }
-      } else {
-        break
-      }
-    }
-    return p
-  }
-
-  getCollectTarget() {}
-
-  collect(value?: any) {
-    if (this.skipCollection) {
-      return
-    }
-    const collectArgs =
-      value !== undefined ? new ArgsClass({ value }, this) : this
-
-    let collectTarget = this.prev
-
-    if (this._collectOverride) {
-      collectTarget.collectedCommands.push(this._collectOverride(collectArgs))
-    } else {
-      collectTarget.collectedCommands.push(this.root._opts.collect(collectArgs))
-    }
-  }
-
-  error(code: ParseError): void {
-    this.root._opts.error(code, this)
-  }
-}

package/src/walker/index.ts

@@ -1,48 +0,0 @@
-import { BasedSchema } from '../types'
-import { ArgsClass } from './args'
-import { AsyncOperation, Opts } from './types'
-
-export const walk = async <T>(
-  schema: BasedSchema,
-  opts: Opts<T>,
-  value: any,
-  asyncOperationHandler?: AsyncOperation<T>
-): Promise<T> => {
-  if (!('collect' in opts)) {
-    opts.collect = () => {}
-  }
-
-  if (!('error' in opts)) {
-    opts.error = () => {}
-  }
-
-  if (asyncOperationHandler) {
-    opts = {
-      ...opts,
-      asyncOperationHandler,
-    }
-  }
-
-  const argsOpts = await opts.init(value, schema, opts.error)
-
-  if (!argsOpts) {
-    return <T>{}
-  }
-
-  if (!argsOpts.value) {
-    argsOpts.value = value
-  }
-
-  const args = new ArgsClass(argsOpts)
-  args.root = args
-  args._opts = opts
-  args._schema = schema
-
-  await args.parse()
-
-  return args.target
-}
-
-export { ArgsClass }
-
-export * from './types'