@based/schema 2.7.0 → 3.0.0

package/dist/test/data/newSchemas.js

@@ -1,4 +1,240 @@
+const defaultFields = {
+    createdAt: {
+        readOnly: true,
+        type: 'timestamp',
+    },
+    updatedAt: {
+        readOnly: true,
+        type: 'timestamp',
+    },
+};
+const testSchema = {
+    language: 'en',
+    translations: ['pt', 'es'],
+    root: {
+        fields: {
+            currentSeason: {
+                type: 'reference',
+                title: 'Currently active season',
+            },
+        },
+    },
+    types: {
+        file: {
+            fields: {
+                ...defaultFields,
+                width: {
+                    type: 'number',
+                },
+                height: {
+                    type: 'number',
+                },
+            },
+        },
+        country: {
+            prefix: 'co',
+            title: 'Country',
+            description: 'This is the country',
+            fields: {
+                ...defaultFields,
+                name: {
+                    type: 'string',
+                    title: 'Country code',
+                },
+                title: {
+                    type: 'text',
+                    title: 'Translated country name',
+                },
+                circleImage: {
+                    type: 'reference',
+                    title: 'Circular flag image',
+                },
+                heartImage: {
+                    type: 'reference',
+                    title: 'Heart-shaped flag image',
+                },
+            },
+        },
+        season: {
+            prefix: 'se',
+            fields: {
+                ...defaultFields,
+                name: {
+                    type: 'string',
+                    title: 'Season name',
+                },
+                winner: {
+                    type: 'reference',
+                    allowedTypes: ['contestant'],
+                },
+                countries: {
+                    type: 'references',
+                    title: 'Participating countries',
+                },
+            },
+        },
+        episode: {
+            prefix: 'ep',
+            fields: {
+                ...defaultFields,
+                episodeType: {
+                    type: 'string', // redemption, grandFinal, nationalFinal or nationalQualifier
+                    title: 'Type of episode',
+                },
+                title: {
+                    type: 'text',
+                    title: 'Episode title',
+                },
+                image: {
+                    type: 'reference',
+                    allowedTypes: ['file'],
+                },
+                startTime: {
+                    type: 'timestamp',
+                    title: 'Start time',
+                },
+                endTime: {
+                    type: 'timestamp',
+                    title: 'End time',
+                },
+                producer: {
+                    type: 'reference',
+                    allowedTypes: ['broadcaster'],
+                },
+                distributors: {
+                    type: 'references',
+                    allowedTypes: ['broadcaster'],
+                },
+            },
+        },
+        votingWindow: {
+            prefix: 'vo',
+            fields: {
+                ...defaultFields,
+                startTime: {
+                    type: 'timestamp',
+                },
+                closeTime: {
+                    type: 'timestamp',
+                },
+                endTime: {
+                    type: 'timestamp',
+                },
+            },
+        },
+        contestant: {
+            prefix: 'ct',
+            fields: {
+                ...defaultFields,
+                name: {
+                    type: 'string',
+                },
+                song: {
+                    type: 'string',
+                },
+                songUrl: {
+                    type: 'string',
+                    format: 'URL',
+                },
+                writer: {
+                    type: 'string',
+                },
+                image: {
+                    type: 'reference',
+                    allowedTypes: ['file'],
+                },
+                content: {
+                    type: 'text',
+                    format: 'html',
+                },
+            },
+        },
+        broadcaster: {
+            prefix: 'br',
+            fields: {
+                ...defaultFields,
+                name: {
+                    type: 'string',
+                },
+                email: {
+                    type: 'string',
+                    format: 'email',
+                },
+                image: {
+                    type: 'reference',
+                    allowedTypes: ['file'],
+                },
+            },
+        },
+        feed: {
+            prefix: 'fe',
+            fields: {
+                ...defaultFields,
+                title: {
+                    type: 'text',
+                },
+                content: {
+                    type: 'text',
+                    format: 'html',
+                },
+                imageUrl: {
+                    type: 'string',
+                    format: 'URL',
+                },
+                videoUrl: {
+                    type: 'string',
+                    format: 'URL',
+                },
+                url: {
+                    type: 'string',
+                    format: 'URL',
+                },
+            },
+        },
+        user: {
+            prefix: 'us',
+            fields: {
+                ...defaultFields,
+                name: { type: 'string' },
+                language: { type: 'string' },
+                notify: { type: 'boolean' },
+                country: { type: 'string' },
+                customerId: {
+                    // stripe customerId
+                    type: 'string',
+                },
+                credits: {
+                    type: 'record',
+                    values: {
+                        type: 'object',
+                        properties: {
+                            purchased: {
+                                type: 'number',
+                            },
+                            earned: {
+                                type: 'number',
+                            },
+                        },
+                    },
+                },
+                voteHistory: {
+                    type: 'record',
+                    values: {
+                        type: 'record',
+                        values: {
+                            type: 'record',
+                            values: {
+                                type: 'number',
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    },
+};
 export const newSchemas = [
+    testSchema,
     {
         types: {
             thing: {
@@ -11,9 +247,13 @@ export const newSchemas = [
             bla: {
                 prefix: 'bl',
                 fields: {
-                    enum: {
-                        enum: ['tony', 'jim'],
+                    createdAt: {
+                        type: 'timestamp',
+                        readOnly: true,
                     },
+                    // enum: {
+                    //   enum: ['tony', 'jim'],
+                    // },
                     setOfNumbers: {
                         type: 'set',
                         items: {
@@ -44,7 +284,7 @@ export const newSchemas = [
                             properties: {
                                 bla: {
                                     type: 'array',
-                                    values: {
+                                    items: {
                                         type: 'object',
                                         properties: {
                                             snux: {
@@ -69,7 +309,6 @@ export const newSchemas = [
                 },
             },
         },
-        $defs: {},
         language: 'en',
         translations: ['de', 'nl', 'ro', 'za', 'ae'],
         root: {
@@ -107,7 +346,6 @@ export const newSchemas = [
                 },
             },
         },
-        $defs: {},
         language: 'en',
         root: {
             fields: {},
@@ -120,7 +358,6 @@ export const newSchemas = [
     {
         language: 'en',
         translations: ['nl'],
-        $defs: {},
         prefixToTypeMapping: {},
         root: {
             fields: {},
@@ -239,7 +476,7 @@ export const newSchemas = [
                         bidirectional: { fromField: 'usedIn' },
                     },
                     hits: { type: 'number' }, // get a bit more going here maybe? what does this mean
-                    membership: { enum: ['Need membership', 'Free'] },
+                    // membership: { enum: ['Need membership', 'Free'] },
                     location: { type: 'text' }, // or string its just city name or smth
                     bio: { type: 'text', format: 'json' }, //has a href and stuff so aarich text
                     tweet: { type: 'string' }, // ask if it needs translation  // 'The 2009 allocation of solar subsidies in Solvakia "was rigged," say a US cable. PM Fico denies it.',

package/dist/test/rest.js

@@ -46,7 +46,7 @@ const schema = {
                         properties: {
                             bla: {
                                 type: 'array',
-                                values: {
+                                items: {
                                     type: 'object',
                                     properties: {
                                         snux: {

package/dist/test/validateSchema/fields.js

@@ -319,7 +319,7 @@ test('arrays', async (t) => {
             fields: {
                 arrayField: {
                     type: 'array',
-                    values: {
+                    items: {
                         type: 'string',
                     },
                 },
@@ -333,13 +333,13 @@ test('arrays', async (t) => {
             fields: {
                 arrayField: {
                     type: 'array',
-                    values: {
+                    items: {
                         type: 'object',
                         properties: {
                             aWrongObjectField: {
                                 type: 'object',
                                 // @ts-ignore
-                                values: { type: 'string' },
+                                items: { type: 'string' },
                             },
                         },
                     },
@@ -354,13 +354,83 @@ test('arrays', async (t) => {
                     'root',
                     'fields',
                     'arrayField',
-                    'values',
+                    'items',
                     'properties',
                     'aWrongObjectField',
-                    'values',
+                    'items',
                 ],
             },
         ],
     });
 });
+test('enum', async (t) => {
+    t.deepEqual(await validateSchema({
+        root: {
+            fields: {
+                enumField: {
+                    enum: ['one', 'two'],
+                },
+            },
+        },
+    }), {
+        valid: true,
+    });
+    t.deepEqual(await validateSchema({
+        root: {
+            fields: {
+                enumField: {
+                    enum: [1, 2],
+                },
+            },
+        },
+    }), {
+        valid: true,
+    });
+    t.deepEqual(await validateSchema({
+        root: {
+            fields: {
+                enumField: {
+                    enum: [{ one: 'one' }, { two: 'two' }],
+                },
+            },
+        },
+    }), {
+        valid: true,
+    });
+    t.deepEqual(await validateSchema({
+        root: {
+            fields: {
+                enumField: {
+                    // @ts-ignore
+                    enum: 'invalidEnum',
+                },
+            },
+        },
+    }), {
+        errors: [
+            {
+                code: ParseError.incorrectFormat,
+                path: ['root', 'fields', 'enumField', 'enum'],
+            },
+        ],
+    });
+    t.deepEqual(await validateSchema({
+        root: {
+            fields: {
+                enumField: {
+                    enum: ['one', 'two'],
+                    // @ts-ignore
+                    invalidProperty: 'invalid',
+                },
+            },
+        },
+    }), {
+        errors: [
+            {
+                code: ParseError.invalidProperty,
+                path: ['root', 'fields', 'enumField', 'invalidProperty'],
+            },
+        ],
+    });
+});
 //# sourceMappingURL=fields.js.map

package/dist/test/validateSchema/realWorld.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/validateSchema/realWorld.js

@@ -0,0 +1,13 @@
+import test from 'ava';
+import { newSchemas } from '../data/newSchemas.js';
+import { validateSchema } from '../../src/index.js';
+test('these schemas should work', async (t) => {
+    await Promise.all(newSchemas.map(async (validSchema) => {
+        const validation = await validateSchema(validSchema);
+        if (!validation.valid) {
+            console.dir(validation.errors, { depth: null });
+        }
+        t.true(validation.valid);
+    }));
+});
+//# sourceMappingURL=realWorld.js.map

package/dist/test/walker.js

@@ -45,7 +45,7 @@ const schema = {
                 },
                 intarray: {
                     type: 'array',
-                    values: {
+                    items: {
                         type: 'integer',
                     },
                 },
@@ -82,7 +82,7 @@ const schema = {
                         properties: {
                             bla: {
                                 type: 'array',
-                                values: {
+                                items: {
                                     type: 'object',
                                     properties: {
                                         snux: {

package/dist/types.d.ts

@@ -0,0 +1,205 @@
+import type { Language } from './languages';
+import type { PartialDeep } from 'type-fest';
+import { ParseError } from './error';
+import { ArgsClass, Path } from './walker';
+import { StringFormat } from './display/string';
+import { NumberFormat } from './display/number';
+import { DateFormat } from './display/timestamp';
+export type AllowedTypes = (string | {
+    type?: string;
+    $filter: any | any[];
+})[];
+export declare const basedSchemaFieldTypes: readonly ["array", "object", "record", "set", "string", "boolean", "number", "json", "integer", "timestamp", "reference", "references", "text", "enum", "cardinality"];
+export type BasedSchemaFieldType = (typeof basedSchemaFieldTypes)[number];
+export declare const isCollection: (type: string) => boolean;
+export type BasedSchemaPattern = string;
+export type BasedSchemaLanguage = Language;
+export declare const languages: string[];
+export type BasedSchemaTypePrefix = string;
+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;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    $comment?: string;
+    examples?: any[];
+    default?: any;
+    customValidator?: (value: any, path: (number | string)[], target: BasedSetTarget) => Promise<boolean>;
+    $defs?: {
+        [key: string]: BasedSchemaField;
+    };
+    $delete?: boolean;
+};
+export type BasedSchemaStringShared = {
+    minLength?: number;
+    maxLength?: number;
+    contentMediaEncoding?: string;
+    contentMediaType?: BasedSchemaContentMediaType;
+    pattern?: BasedSchemaPattern;
+    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';
+    display?: StringFormat;
+    multiline?: boolean;
+};
+type NumberDefaults = {
+    multipleOf?: number;
+    minimum?: number;
+    maximum?: number;
+    exclusiveMaximum?: boolean;
+    exclusiveMinimum?: boolean;
+};
+export type BasedNumberDisplay = NumberFormat;
+export type BasedTimestampDisplay = DateFormat;
+export type BasedSchemaFieldString = {
+    type: 'string';
+} & BasedSchemaFieldShared & BasedSchemaStringShared;
+export type BasedSchemaFieldEnum = {
+    enum: any[];
+    type?: '';
+} & BasedSchemaFieldShared;
+export type BasedSchemaFieldCardinality = {
+    type: 'cardinality';
+} & BasedSchemaFieldShared;
+export type BasedSchemaFieldNumber = NumberDefaults & {
+    type: 'number';
+    display?: BasedNumberDisplay;
+} & BasedSchemaFieldShared;
+export type BasedSchemaFieldInteger = NumberDefaults & {
+    type: 'integer';
+    display?: BasedNumberDisplay;
+} & BasedSchemaFieldShared;
+export type BasedSchemaFieldTimeStamp = NumberDefaults & {
+    type: 'timestamp';
+    display?: BasedTimestampDisplay;
+} & BasedSchemaFieldShared;
+export type BasedSchemaFieldBoolean = {
+    type: 'boolean';
+} & BasedSchemaFieldShared;
+export type BasedSchemaFieldJSON = {
+    type: 'json';
+} & BasedSchemaFieldShared;
+export type BasedSchemaFieldPrimitive = BasedSchemaFieldString | BasedSchemaFieldNumber | BasedSchemaFieldInteger | BasedSchemaFieldTimeStamp | BasedSchemaFieldJSON | BasedSchemaFieldBoolean | BasedSchemaFieldEnum;
+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;
+export type BasedSchemaFieldReference = {
+    type: 'reference';
+    bidirectional?: {
+        fromField: string;
+    };
+    allowedTypes?: AllowedTypes;
+} & BasedSchemaFieldShared;
+export type BasedSchemaFieldReferences = {
+    type: 'references';
+    bidirectional?: {
+        fromField: string;
+    };
+    allowedTypes?: AllowedTypes;
+} & BasedSchemaFieldShared;
+export type BasedSchemaFields = {
+    string: BasedSchemaFieldString;
+    number: BasedSchemaFieldNumber;
+    integer: BasedSchemaFieldInteger;
+    timestamp: BasedSchemaFieldTimeStamp;
+    json: BasedSchemaFieldJSON;
+    boolean: BasedSchemaFieldBoolean;
+    enum: BasedSchemaFieldEnum;
+    array: BasedSchemaFieldArray;
+    object: BasedSchemaFieldObject;
+    set: BasedSchemaFieldSet;
+    record: BasedSchemaFieldRecord;
+    reference: BasedSchemaFieldReference;
+    references: BasedSchemaFieldReferences;
+    text: BasedSchemaFieldText;
+    cardinality: BasedSchemaFieldCardinality;
+};
+export type BasedSchemaField = BasedSchemaFields[keyof BasedSchemaFields] | (BasedSchemaFieldShared & {
+    type?: '';
+    isRequired?: boolean;
+    $ref: string;
+});
+export type BasedSchemaType = {
+    fields: {
+        [name: string]: BasedSchemaField;
+    };
+    title?: string;
+    description?: string;
+    prefix?: BasedSchemaTypePrefix;
+    examples?: any[];
+    required?: string[];
+    $defs?: {
+        [key: string]: BasedSchemaField;
+    };
+    $delete?: boolean;
+};
+export type BasedSchema = {
+    language: BasedSchemaLanguage;
+    translations?: BasedSchemaLanguage[];
+    languageFallbacks?: Partial<Record<BasedSchemaLanguage, BasedSchemaLanguage[]>>;
+    root: BasedSchemaType;
+    $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;
+    };
+};
+export {};

package/dist/types.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.languages = exports.isCollection = exports.basedSchemaFieldTypes = void 0;
+const languages_1 = require("./languages");
+exports.basedSchemaFieldTypes = [
+    'array',
+    'object',
+    'record',
+    'set',
+    'string',
+    'boolean',
+    'number',
+    'json',
+    'integer',
+    'timestamp',
+    'reference',
+    'references',
+    'text',
+    'enum',
+    'cardinality',
+];
+const isCollection = (type) => {
+    return type === 'array' || type === 'object' || type === 'record';
+};
+exports.isCollection = isCollection;
+exports.languages = Object.keys(languages_1.languages);
+//# sourceMappingURL=types.js.map

package/dist/updateSchema.d.ts

@@ -0,0 +1,2 @@
+import { BasedSchema, BasedSchemaPartial } from './types';
+export declare const updateSchema: (newSchema: BasedSchemaPartial, oldSchema?: BasedSchema) => Promise<BasedSchema>;