@based/schema 0.0.1

package/src/types.ts

@@ -0,0 +1,277 @@
+import type { Language } from './languages'
+import type { PartialDeep } from 'type-fest'
+
+// 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'
+  | 'number'
+  | 'float'
+  | 'json'
+  | 'integer'
+  | 'timestamp'
+  | 'reference'
+  | 'references'
+  | 'text'
+
+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'
+  | string
+
+export type BasedSchemaFieldShared = {
+  $id?: string
+  $schema?: string
+  isRequired?: boolean
+  title?: string
+  description?: string
+  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 }
+}
+
+// -------------- Primitive ---------------
+export type BasedSchemaFieldString = {
+  type: 'string'
+  minLength?: number
+  maxLength?: number
+  contentMediaEncoding?: string // base64
+  contentMediaType?: BasedSchemaContentMediaType
+  pattern?: BasedSchemaPattern
+  format?: 'email' | 'hostname' | 'ipv4' | 'ipv6' | 'uuid' | 'uri'
+  // maybe add some more? e.g. phone
+} & BasedSchemaFieldShared
+
+export type BasedSchemaFieldEnum = {
+  enum: any[] // this changes behaviour pretty extreme
+  // important to type as well because we want to enum based on the type e.g. for references
+} & BasedSchemaFieldShared
+
+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 BasedSchemaFieldHyperLogLog = {
+  type: 'hyperloglog'
+  // allow any (objects become hashes)
+}
+
+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[]
+  contentMediaType?: BasedSchemaContentMediaType
+  minLength?: number
+  maxLength?: number
+  contentMediaEncoding?: string // base64
+  pattern?: BasedSchemaPattern
+} & BasedSchemaFieldShared
+
+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
+  | BasedSchemaFieldHyperLogLog
+  | {
+      isRequired?: boolean // our own
+      $ref: string // to mimic json schema will just load it in place (so only for setting)
+    }
+
+export type BasedSchemaType = {
+  fields: {
+    [name: string]: BasedSchemaField
+  }
+  title?: string
+  description?: string
+  prefix?: BasedSchemaTypePrefix
+  examples?: any[]
+  required?: string[]
+  $defs?: { [key: string]: BasedSchemaField }
+}
+
+// this is the return value,, optional for insert
+export type BasedSchema = {
+  languages: 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
+  $language?: BasedSchemaLanguage
+}
+
+export type BasedSetHandlers = {
+  collect: (props: {
+    path: (string | number)[]
+    value: any
+    typeSchema: BasedSchemaType
+    fieldSchema: BasedSchemaField
+    target: BasedSetTarget
+  }) => void
+
+  // has to be fixed / decided upon
+  // ['bla[0].xxx', '']
+  // [bla, [0]', xxx]
+  // (number|string)[]
+  // typeschema, target) => Promise<boolean>
+
+  // $filter
+  referenceFilterCondition: (
+    referenceId: string,
+    $filter: any
+  ) => Promise<boolean>
+}

package/src/validateSchema.ts

@@ -0,0 +1,56 @@
+import {
+  BasedSchemaPartial,
+  BasedSchemaFieldPartial,
+  BasedSchemaTypePartial,
+  BasedSchemaField,
+} from './types'
+
+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.languages && !Array.isArray(schema.languages)) {
+    throw new Error('Languages needs to be an array')
+  }
+
+  if (schema.$defs) {
+    // first defs ofc
+  }
+
+  if (schema.root) {
+  }
+
+  if (schema.types) {
+    for (const type in schema.types) {
+      validateType(schema, type, schema.types[type])
+    }
+  }
+
+  return schema
+}

package/test/setWalker.ts

@@ -0,0 +1,197 @@
+import test from 'ava'
+import { BasedSchema, setWalker } from '../src/index'
+
+const schema: BasedSchema = {
+  types: {
+    bla: {
+      prefix: 'bl',
+      fields: {
+        snurp: {
+          type: 'array',
+          values: {
+            type: 'object',
+            properties: {
+              x: {
+                type: 'array',
+                values: {
+                  type: 'number',
+                },
+              },
+            },
+          },
+        },
+        specialArray: {
+          type: 'array',
+          values: {
+            type: 'string',
+          },
+        },
+        snurpArray: {
+          type: 'array',
+          values: {
+            type: 'number',
+          },
+        },
+        powerLevel: {
+          type: 'integer',
+        },
+        form: {
+          title: 'A registration form',
+          description: 'A simple form example.',
+          type: 'object',
+          required: ['firstName', 'lastName'],
+          properties: {
+            bla: {
+              type: 'references',
+            },
+            blab: {
+              type: 'references',
+            },
+            snurp: {
+              type: 'reference',
+            },
+            things: {
+              enum: ['yuzi', 'jux', 'mr tony', 9000],
+            },
+            blub: {
+              type: 'set',
+              items: { type: 'string' },
+            },
+            json: {
+              type: 'json',
+            },
+            firstName: {
+              type: 'string',
+              title: 'First name',
+              default: 'Chuck',
+            },
+            lastName: {
+              type: 'string',
+              title: 'Last name',
+            },
+            age: {
+              type: 'integer',
+              title: 'Age',
+            },
+            bio: {
+              type: 'string',
+              title: 'Bio',
+            },
+            password: {
+              type: 'string',
+              title: 'Password',
+              minLength: 3,
+            },
+            telephone: {
+              type: 'string',
+              title: 'Telephone',
+              minLength: 10,
+            },
+          },
+        },
+      },
+    },
+  },
+  $defs: {},
+  languages: ['en'],
+  root: {
+    fields: {},
+  },
+  prefixToTypeMapping: {
+    bl: 'bla',
+  },
+}
+
+// $value
+// $default
+
+// $noRoot
+
+// $delete -> change for set / references
+
+// $merge: false,
+
+// $increment
+// $decrement
+
+// $assign
+// $insert
+// $remove
+// $push: 7,
+// $unshift (    $unshift: {$value: 123,$maxLen: 10,},)
+//     $alias: 'maTestWithAlias',
+// aliases (set
+
+// parse formats for string e.g. uri / email etc
+
+test.serial('collect correctly', async (t) => {
+  const results: { path: (string | number)[]; value: any }[] = []
+  await setWalker(
+    schema,
+    {
+      $id: 'bl1',
+      form: {
+        lastName: 'de beer',
+        bla: ['bl123', 'bl234'],
+        blab: { $add: ['bl456'] },
+        blub: ['x'],
+        json: { bla: 1, x: 2, y: 3 },
+        snurp: 'blx12',
+        things: 'mr tony',
+        password: 'mypassword!',
+      },
+      snurpArray: {
+        $assign: {
+          $idx: 0,
+          $value: 100,
+        },
+      },
+      specialArray: {
+        $insert: {
+          $value: ['a', 'b', 'c'],
+          $idx: 0,
+        },
+      },
+      snurp: [
+        {
+          x: [1, 2, 3],
+        },
+      ],
+    },
+    {
+      collect: ({ path, value, typeSchema, fieldSchema, target }) => {
+        results.push({
+          path,
+          value,
+        })
+      },
+      referenceFilterCondition: async (id, filter) => {
+        return true
+      },
+    }
+  )
+
+  const result = [
+    { path: ['form', 'lastName'], value: 'de beer' },
+    { path: ['form', 'json'], value: '{"bla":1,"x":2,"y":3}' },
+    { path: ['form', 'snurp'], value: 'blx12' },
+    { path: ['form', 'things'], value: 2 },
+    { path: ['form', 'password'], value: 'mypassword!' },
+    {
+      path: ['snurpArray'],
+      value: { $assign: { $idx: 0, $value: 100 } },
+    },
+    {
+      path: ['specialArray'],
+      value: { $insert: { $value: ['a', 'b', 'c'], $idx: 0 } },
+    },
+    { path: ['snurp', 0, 'x', 0], value: 1 },
+    { path: ['snurp', 0, 'x', 1], value: 2 },
+    { path: ['snurp', 0, 'x', 2], value: 3 },
+    { path: ['form', 'bla'], value: ['bl123', 'bl234'] },
+    { path: ['form', 'blab'], value: { $add: ['bl456'] } },
+    { path: ['form', 'blub'], value: ['x'] },
+  ]
+
+  t.deepEqual(results, result)
+})

package/test/validateSchema.ts

@@ -0,0 +1,42 @@
+import test from 'ava'
+import { validateSchema } from '../src/index'
+
+test.serial('throw on invalid schema', async (t) => {
+  const prefixError = t.throws(() => {
+    validateSchema({
+      $defs: {
+        yuzi: {
+          type: 'string',
+          title: 'BLA',
+          description: 'SNURP',
+        },
+      },
+      types: {
+        bla: {
+          prefix: 'fix',
+          fields: {
+            yuzi: {
+              type: 'object',
+              customValidator: async (value, path, target) => {
+                return true
+              },
+              properties: {
+                gurt: {
+                  $ref: '/$defs/yuzi',
+                },
+                flap: {
+                  enum: ['bla', 'blap', 'flip'],
+                },
+              },
+            },
+          },
+        },
+      },
+    })
+  })
+
+  t.is(
+    prefixError.message,
+    'Incorrect prefix "fix" for type "bla" has to be a string of 2 alphanumerical characters e.g. "Az", "ab", "cc", "10"'
+  )
+})

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src/**/*", "src/**/*.json"],
+  "exclude": ["node_modules", "test", "dist", "tmp", "examples"]
+}