@based/schema 0.0.9 → 0.0.11

package/test/string.ts

@@ -0,0 +1,183 @@
+import test from 'ava'
+import { BasedSchema, setWalker, BasedSetHandlers } from '../src/index'
+
+const schema: BasedSchema = {
+  types: {
+    bla: {
+      prefix: 'bl',
+      fields: {
+        name: {
+          minLength: 3,
+          maxLength: 6,
+          type: 'string',
+        },
+        phonkName: {
+          type: 'string',
+          pattern: '\\${1,4}',
+        },
+        bla: {
+          type: 'set',
+          items: { type: 'string', minLength: 3, maxLength: 6 },
+        },
+      },
+    },
+  },
+  $defs: {},
+  languages: ['en'],
+  root: {
+    fields: {},
+  },
+  prefixToTypeMapping: {
+    bl: 'bla',
+  },
+}
+
+const createHandlers = (): {
+  results: { path: (number | string)[]; value: any }[]
+  handlers: BasedSetHandlers
+} => {
+  const results: { path: (number | string)[]; value: any }[] = []
+  const handlers = {
+    collect: ({ path, value, typeSchema, fieldSchema, target }) => {
+      results.push({ path, value })
+    },
+    checkRequiredFields: async (paths) => {
+      return true
+    },
+    referenceFilterCondition: async (id, filter) => {
+      return true
+    },
+  }
+  return { results, handlers }
+}
+
+test('string max length', async (t) => {
+  const { handlers, results } = createHandlers()
+  await t.throwsAsync(
+    setWalker(
+      schema,
+      {
+        $id: 'bl1',
+        name: 'ax',
+      },
+      handlers
+    )
+  )
+  await t.throwsAsync(
+    setWalker(
+      schema,
+      {
+        $id: 'bl1',
+        name: 'axaxaxax',
+      },
+      handlers
+    )
+  )
+  await setWalker(
+    schema,
+    {
+      $id: 'bl1',
+      name: 'xaxx',
+    },
+    handlers
+  )
+  t.deepEqual(results, [{ path: ['name'], value: 'xaxx' }])
+})
+
+test('set with strings', async (t) => {
+  const { handlers, results } = createHandlers()
+  await t.throwsAsync(
+    setWalker(
+      schema,
+      {
+        $id: 'bl1',
+        bla: ['ax', 'axa', 'axxxxa'],
+      },
+      handlers
+    )
+  )
+  t.deepEqual(results, [])
+  await setWalker(
+    schema,
+    {
+      $id: 'bl1',
+      bla: ['axx', 'axxxx', 'blaaa'],
+    },
+    handlers
+  )
+  t.deepEqual(results, [
+    { path: ['bla'], value: { $value: ['axx', 'axxxx', 'blaaa'] } },
+  ])
+})
+
+test('string pattern', async (t) => {
+  const { handlers, results } = createHandlers()
+  await t.throwsAsync(
+    setWalker(
+      schema,
+      {
+        $id: 'bl1',
+        phonkName: 'blabla',
+      },
+      handlers
+    )
+  )
+  t.deepEqual(results, [])
+  await setWalker(
+    schema,
+    {
+      $id: 'bl1',
+      phonkName: 'bla$',
+    },
+    handlers
+  )
+  t.deepEqual(results, [{ path: ['phonkName'], value: 'bla$' }])
+})
+
+test('setting $default', async (t) => {
+  const { handlers, results } = createHandlers()
+  await t.throwsAsync(
+    setWalker(
+      schema,
+      {
+        $id: 'bl1',
+        phonkName: { $default: 'blabla' },
+      },
+      handlers
+    )
+  )
+  t.deepEqual(results, [])
+  await setWalker(
+    schema,
+    {
+      $id: 'bl1',
+      phonkName: { $default: 'bla$' },
+    },
+    handlers
+  )
+  t.deepEqual(results, [{ path: ['phonkName'], value: { $default: 'bla$' } }])
+})
+
+test('setting $value', async (t) => {
+  const { handlers, results } = createHandlers()
+  await t.throwsAsync(
+    setWalker(
+      schema,
+      {
+        $id: 'bl1',
+        phonkName: { $value: 'blabla' },
+      },
+      handlers
+    )
+  )
+  t.deepEqual(results, [])
+  await setWalker(
+    schema,
+    {
+      $id: 'bl1',
+      phonkName: { $value: 'bla$' },
+    },
+    handlers
+  )
+  t.deepEqual(results, [{ path: ['phonkName'], value: { $value: 'bla$' } }])
+})

package/test/text.ts

@@ -0,0 +1,171 @@
+import test from 'ava'
+import { BasedSchema, setWalker, BasedSetOptionalHandlers } from '../src/index'
+
+const schema: BasedSchema = {
+  types: {
+    bla: {
+      prefix: 'bl',
+      fields: {
+        name: {
+          minLength: 3,
+          maxLength: 6,
+          type: 'text',
+        },
+      },
+    },
+  },
+  $defs: {},
+  languages: ['en', 'de'],
+  root: {
+    fields: {},
+  },
+  prefixToTypeMapping: {
+    bl: 'bla',
+  },
+}
+
+const createHandlers = (): {
+  results: { path: (number | string)[]; value: any }[]
+  handlers: BasedSetOptionalHandlers
+} => {
+  const results: { path: (number | string)[]; value: any }[] = []
+  const handlers = {
+    collect: ({ path, value, typeSchema, fieldSchema, target }) => {
+      console.log('collect', path)
+      results.push({ path, value })
+    },
+    checkRequiredFields: async (paths) => {
+      return true
+    },
+    referenceFilterCondition: async (id, filter) => {
+      return true
+    },
+  }
+  return { results, handlers }
+}
+
+test('text max length', async (t) => {
+  const { handlers, results } = createHandlers()
+  await t.throwsAsync(
+    setWalker(
+      schema,
+      {
+        $id: 'bl1',
+        name: {
+          de: 'ax',
+          nl: 'axa',
+        },
+      },
+      handlers
+    )
+  )
+  await t.throwsAsync(
+    setWalker(
+      schema,
+      {
+        $id: 'bl1',
+        $language: 'de',
+        name: 'axaxaxax',
+      },
+      handlers
+    )
+  )
+  await setWalker(
+    schema,
+    {
+      $id: 'bl1',
+      $language: 'en',
+      name: 'xaxx',
+    },
+    handlers
+  )
+  t.deepEqual(results, [{ path: ['name'], value: { en: 'xaxx' } }])
+})
+
+test('text wrong language', async (t) => {
+  const { handlers, results } = createHandlers()
+  await t.throwsAsync(
+    setWalker(
+      schema,
+      {
+        $id: 'bl1',
+        name: {
+          de: 'xaxx',
+          nl: 'xaxx',
+          es: 'flap',
+        },
+      },
+      handlers
+    )
+  )
+
+  await setWalker(
+    schema,
+    {
+      $id: 'bl1',
+      $language: 'de',
+      name: 'blabla',
+    },
+    handlers
+  )
+
+  //TODO fix
+  t.deepEqual(results, [
+    { path: ['name', 'de'], value: 'blabla' },
+    { path: ['name'], value: { de: 'blabla' } },
+  ])
+})
+
+test('default', async (t) => {
+  const { handlers, results } = createHandlers()
+  await setWalker(
+    schema,
+    {
+      $id: 'bl1',
+      $language: 'de',
+      name: { $default: 'xaxx' },
+    },
+    handlers
+  )
+  await setWalker(
+    schema,
+    {
+      $id: 'bl1',
+      $language: 'de',
+      name: { de: { $default: 'xaxx' } },
+    },
+    handlers
+  )
+  t.deepEqual(results, [
+    { path: ['name'], value: { de: { $default: 'xaxx' } } },
+    { path: ['name'], value: { de: { $default: 'xaxx' } } },
+  ])
+})
+
+test('value', async (t) => {
+  const { handlers, results } = createHandlers()
+  await t.throwsAsync(
+    setWalker(
+      schema,
+      {
+        $id: 'bl1',
+        $language: 'de',
+        name: { $value: 'xaxx' },
+      },
+      handlers
+    )
+  )
+  t.deepEqual(results, [])
+
+  await setWalker(
+    schema,
+    {
+      $id: 'bl1',
+      $language: 'de',
+      name: { de: { $value: 'xaxx' } },
+    },
+    handlers
+  )
+  console.log('-------------->', results)
+  t.deepEqual(results, [{ path: ['name', 'de'], value: { $value: 'xaxx' } }])
+})

package/test/validateSchema.ts

@@ -34,7 +34,6 @@ test.serial('throw on invalid schema', async (t) => {
       },
     })
   })
-
   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/test/walker.ts

@@ -0,0 +1,99 @@
+import test from 'ava'
+import { BasedSchema, validateType, walk } from '../src/index'
+
+const schema: BasedSchema = {
+  types: {
+    bla: {
+      prefix: 'bl',
+      fields: {
+        name: {
+          minLength: 3,
+          maxLength: 6,
+          type: 'string',
+        },
+        phonkName: {
+          type: 'string',
+          pattern: '\\${1,4}',
+        },
+        bla: {
+          type: 'set',
+          items: { type: 'string', minLength: 3, maxLength: 6 },
+        },
+      },
+    },
+  },
+  $defs: {},
+  languages: ['en'],
+  root: {
+    fields: {},
+  },
+  prefixToTypeMapping: {
+    bl: 'bla',
+  },
+}
+
+test('walker', async (t) => {
+  const x = await walk(
+    {
+      schema,
+      init: async () => {
+        console.log('init!\n')
+        return { lullz: true }
+      },
+      parsers: {
+        keys: {
+          $list: async (args) => {
+            return {
+              ...args,
+              value: { flapdrol: true },
+            }
+          },
+        },
+        fields: {
+          // string: () => {}
+        },
+        any: async (args) => {
+          return args
+        },
+      },
+      collect: (args) => {
+        // console.log('    lulz collect dat command', args.path)
+        return args.path.join('.')
+      },
+      backtrack: (collectedCommands) => {
+        console.log('    \n-----------BACK TRACK GOOD GO', collectedCommands)
+        // if return next btrack will not receive  backtrack from commands
+        return collectedCommands
+      },
+      requiresAsyncValidaton: async (validateType) => {
+        // console.info('lullz async validaion at the end!')
+        return true
+      },
+    },
+    {
+      gurk: [1, 2, 3, 4],
+      x: {
+        y: {
+          z: {
+            a: 10,
+            b: 20,
+            gur: {
+              x: true,
+              y: true,
+              $list: {
+                $sort: true,
+              },
+            },
+            c: 40,
+            $list: true,
+          },
+        },
+      },
+    }
+  )
+
+  console.info('------------')
+  //   console.info(x)
+
+  t.true(true)
+})

package/dist/deepPartial.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=deepPartial.js.map

package/dist/deepPartial.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"deepPartial.js","sourceRoot":"","sources":["../src/deepPartial.ts"],"names":[],"mappings":""}

package/dist/schema.d.ts

@@ -1 +0,0 @@
-export type Schema = {};

package/dist/schema.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=schema.js.map

package/dist/schema.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema.js","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":""}

package/dist/set/checkDefaultAndValue.d.ts

@@ -1,3 +0,0 @@
-import { BasedSchemaFields } from '../types';
-import { Parser } from './types';
-export declare const parseValueAndDefault: Parser<keyof BasedSchemaFields>;

package/dist/set/checkDefaultAndValue.js

@@ -1,33 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseValueAndDefault = void 0;
-const error_1 = require("./error");
-const parsers_1 = __importDefault(require("./parsers"));
-const parseValueAndDefault = async (path, value, fieldSchema, typeSchema, target, handlers, noCollect) => {
-    let handled = false;
-    if (typeof value === 'object') {
-        const typeDef = fieldSchema.type ?? ('enum' in fieldSchema ? 'enum' : '');
-        const parse = parsers_1.default[typeDef];
-        if (value.$value !== undefined) {
-            // TODO: for errors handle path a bit smarter...
-            parse(path, value.$value, fieldSchema, typeSchema, target, handlers, true);
-            handled = true;
-        }
-        if (value.$default !== undefined) {
-            if (value.$value !== undefined) {
-                (0, error_1.error)(path, error_1.ParseError.valueAndDefault);
-            }
-            parse(path, value.$default, fieldSchema, typeSchema, target, handlers, true);
-            handled = true;
-        }
-    }
-    if (handled && !noCollect) {
-        handlers.collect({ path, value, typeSchema, fieldSchema, target });
-    }
-    return handled;
-};
-exports.parseValueAndDefault = parseValueAndDefault;
-//# sourceMappingURL=checkDefaultAndValue.js.map

package/dist/set/checkDefaultAndValue.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"checkDefaultAndValue.js","sourceRoot":"","sources":["../../src/set/checkDefaultAndValue.ts"],"names":[],"mappings":";;;;;;AAEA,mCAA2C;AAC3C,wDAA+B;AAExB,MAAM,oBAAoB,GAAoC,KAAK,EACxE,IAAI,EACJ,KAAK,EACL,WAAW,EACX,UAAU,EACV,MAAM,EACN,QAAQ,EACR,SAAS,EACS,EAAE;IACpB,IAAI,OAAO,GAAG,KAAK,CAAA;IACnB,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;QAC7B,MAAM,OAAO,GAAG,WAAW,CAAC,IAAI,IAAI,CAAC,MAAM,IAAI,WAAW,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAA;QACzE,MAAM,KAAK,GAAG,iBAAO,CAAC,OAAO,CAAC,CAAA;QAC9B,IAAI,KAAK,CAAC,MAAM,KAAK,SAAS,EAAE;YAC9B,gDAAgD;YAChD,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,MAAM,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAA;YAC1E,OAAO,GAAG,IAAI,CAAA;SACf;QACD,IAAI,KAAK,CAAC,QAAQ,KAAK,SAAS,EAAE;YAChC,IAAI,KAAK,CAAC,MAAM,KAAK,SAAS,EAAE;gBAC9B,IAAA,aAAK,EAAC,IAAI,EAAE,kBAAU,CAAC,eAAe,CAAC,CAAA;aACxC;YACD,KAAK,CACH,IAAI,EACJ,KAAK,CAAC,QAAQ,EACd,WAAW,EACX,UAAU,EACV,MAAM,EACN,QAAQ,EACR,IAAI,CACL,CAAA;YACD,OAAO,GAAG,IAAI,CAAA;SACf;KACF;IACD,IAAI,OAAO,IAAI,CAAC,SAAS,EAAE;QACzB,QAAQ,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,EAAE,CAAC,CAAA;KACnE;IACD,OAAO,OAAO,CAAA;AAChB,CAAC,CAAA;AAtCY,QAAA,oBAAoB,wBAsChC"}

package/dist/set/enum.d.ts

@@ -1,2 +0,0 @@
-export declare const enum  {
-}

package/dist/set/enum.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-() => {
-    if ('enum' in fieldSchema) {
-        const enumValues = fieldSchema.enum;
-        for (let i = 0; i < enumValues.length; i++) {
-            if (deepEqual(enumValues[i], value)) {
-                collect(path, i, typeSchema, fieldSchema, target);
-                return;
-            }
-        }
-        throw createError(path, target.type, 'enum', value);
-    }
-};
-//# sourceMappingURL=enum.js.map

package/dist/set/enum.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"enum.js","sourceRoot":"","sources":["../../src/set/enum.ts"],"names":[],"mappings":";;AAAoB,GAAG,EAAE;IAErB,IAAI,MAAM,IAAI,WAAW,EAAE;QACvB,MAAM,UAAU,GAAG,WAAW,CAAC,IAAI,CAAA;QACnC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YAC1C,IAAI,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE;gBACnC,OAAO,CAAC,IAAI,EAAE,CAAC,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,CAAC,CAAA;gBACjD,OAAM;aACP;SACF;QACD,MAAM,WAAW,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,CAAA;KACpD;AACP,CAAC,CAAA"}

package/dist/set/fieldValidator.d.ts

@@ -1,6 +0,0 @@
-import { BasedSchemaField, BasedSchemaType, BasedSetTarget } from '../types';
-declare const fieldValidator: {
-    [key: string]: (path: (string | number)[], value: any, fieldSchema: BasedSchemaField, typeSchema: BasedSchemaType, target: BasedSetTarget, collect: (path: (string | number)[], value: any, // parsed value
-    typeSchema: BasedSchemaType, fieldSchema: BasedSchemaField, target: BasedSetTarget) => void) => void;
-};
-export default fieldValidator;