@based/schema 2.5.3 → 2.6.0

package/dist/src/compat/index.d.ts

@@ -0,0 +1,2 @@
+export * from './newToOld.js';
+export * from './oldToNew.js';

package/dist/src/compat/index.js

@@ -0,0 +1,3 @@
+export * from './newToOld.js';
+export * from './oldToNew.js';
+//# sourceMappingURL=index.js.map

package/dist/src/compat/newToOld.d.ts

@@ -0,0 +1,3 @@
+import { BasedSchema } from '../types.js';
+import { BasedOldSchema } from './oldSchemaType.js';
+export declare const convertNewToOld: (schema: BasedSchema) => Partial<BasedOldSchema>;

package/dist/src/compat/newToOld.js

@@ -0,0 +1,76 @@
+const metaChecker = (field) => {
+    return (field === 'validation' ||
+        field === 'format' ||
+        field === 'index' ||
+        field === 'description' ||
+        field === 'title' ||
+        field === 'examples' ||
+        field === 'ui' ||
+        field === 'isRequired' ||
+        field === 'title' ||
+        field === 'description' ||
+        field === 'index' ||
+        field === 'readOnly' ||
+        field === 'writeOnly' ||
+        field === '$comment' ||
+        field === 'examples' ||
+        field === 'default' ||
+        field === 'customValidator' ||
+        field === 'value' ||
+        field === 'path' ||
+        field === 'target' ||
+        field === 'minLength' ||
+        field === 'maxLength' ||
+        field === 'contentMediaEncoding' ||
+        field === 'pattern' ||
+        field === 'display' ||
+        field === 'multiline' ||
+        field === 'multipleOf' ||
+        field === 'minimum' ||
+        field === 'maximum' ||
+        field === 'exclusiveMaximum' ||
+        field === 'exclusiveMinimum' ||
+        field === '$delete');
+};
+const excludedFields = (field) => {
+    return field === 'language' || field === 'translations' || field === '$defs';
+};
+export const convertNewToOld = (schema) => {
+    const tmpSchema = {};
+    const walker = (target, source) => {
+        for (const i in source) {
+            if (source[i] && typeof source[i] === 'object' && i in target === false) {
+                target[i] = source[i].length ? [] : {};
+                walker(target[i], source[i]);
+            }
+            else if (!metaChecker(i)) {
+                target[i] = source[i];
+            }
+            else {
+                target.meta = {};
+                for (const i in source) {
+                    if (metaChecker(i) && typeof source[i] !== 'object') {
+                        if (i === 'title') {
+                            target.meta = { ...target.meta, name: source[i] };
+                        }
+                        else {
+                            target.meta = { ...target.meta, [i]: source[i] };
+                        }
+                        delete source[i];
+                    }
+                }
+            }
+        }
+    };
+    walker(tmpSchema, schema);
+    if ((tmpSchema.meta = {}))
+        delete tmpSchema.meta;
+    for (const i in tmpSchema) {
+        if (excludedFields(i)) {
+            delete tmpSchema[i];
+        }
+    }
+    tmpSchema.languages = [schema.language, ...schema?.translations];
+    return tmpSchema;
+};
+//# sourceMappingURL=newToOld.js.map

package/dist/src/compat/oldSchemaType.d.ts

@@ -0,0 +1,69 @@
+type FieldType = 'float' | 'boolean' | 'number' | 'int' | 'string' | 'text' | 'id' | 'digest' | 'url' | 'email' | 'phone' | 'geo' | 'type' | 'timestamp';
+type FieldSchemaObject = {
+    type: 'object';
+    properties: {
+        [key: string]: FieldSchema;
+    };
+    meta?: any;
+    timeseries?: boolean;
+};
+type FieldSchemaJson = {
+    type: 'json';
+    properties?: {
+        [key: string]: FieldSchema;
+    };
+    meta?: any;
+    timeseries?: boolean;
+};
+type FieldSchemaRecord = {
+    type: 'record';
+    values: FieldSchema;
+    meta?: any;
+    timeseries?: boolean;
+};
+type FieldSchemaReferences = {
+    type: 'reference' | 'references';
+    bidirectional?: {
+        fromField: string;
+    };
+    meta?: any;
+    timeseries?: boolean;
+};
+type FieldSchemaOther = {
+    type: FieldType;
+    meta?: any;
+    timeseries?: boolean;
+};
+type FieldSchemaArrayLike = {
+    type: 'set' | 'array';
+    items: FieldSchema;
+    meta?: any;
+    timeseries?: boolean;
+};
+type FieldSchema = FieldSchemaObject | FieldSchemaRecord | FieldSchemaArrayLike | FieldSchemaJson | FieldSchemaReferences | FieldSchemaOther;
+type Fields = Record<string, FieldSchema>;
+type HierarchySchema = false | {
+    [key: string]: false | {
+        excludeAncestryWith: string[];
+    } | {
+        includeAncestryWith: string[];
+    };
+};
+type TypeSchema = {
+    prefix?: string;
+    hierarchy?: HierarchySchema;
+    fields?: Fields;
+    meta?: any;
+};
+type Types = {
+    [key: string]: TypeSchema;
+};
+export type BasedOldSchema = {
+    sha?: string;
+    languages?: string[];
+    types: Types;
+    rootType?: Pick<TypeSchema, 'fields' | 'prefix' | 'meta'>;
+    idSeedCounter?: number;
+    prefixToTypeMapping?: Record<string, string>;
+};
+export {};

package/dist/src/compat/oldSchemaType.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=oldSchemaType.js.map

package/dist/src/compat/oldToNew.d.ts

@@ -0,0 +1,3 @@
+import { BasedSchema } from '../types.js';
+import { BasedOldSchema } from './oldSchemaType.js';
+export declare const convertOldToNew: (oldSchema: BasedOldSchema) => BasedSchema;

package/dist/src/compat/oldToNew.js

@@ -0,0 +1,35 @@
+export const convertOldToNew = (oldSchema) => {
+    const tempSchema = {};
+    const walker = (source, target) => {
+        for (const i in source) {
+            if (i === 'languages' && source[i].length) {
+                target.language = source[i][0];
+                target.translations = source[i].filter((_, i) => i !== 0);
+            }
+            else if (typeof source[i] === 'object' && i in target === false) {
+                if (i === 'meta' &&
+                    !Object.keys(source[i]).includes('properties' || 'type')) {
+                    for (const j in source[i]) {
+                        if (j === 'name') {
+                            target.title = source[i][j];
+                        }
+                        else {
+                            target[j] = source[i][j];
+                        }
+                    }
+                }
+                else {
+                    target[i] = source[i].length ? [] : {};
+                    walker(source[i], target[i]);
+                }
+            }
+            else if (i !== 'meta') {
+                target[i] = source[i];
+            }
+        }
+    };
+    walker(oldSchema, tempSchema);
+    tempSchema.$defs = {};
+    return tempSchema;
+};
+//# sourceMappingURL=oldToNew.js.map

package/dist/src/index.d.ts

@@ -3,3 +3,4 @@ export * from './validateSchema.js';
 export * from './walker/index.js';
 export * from './set/index.js';
 export * from './display/index.js';
+export * from './compat/index.js';

package/dist/src/index.js

@@ -3,4 +3,5 @@ export * from './validateSchema.js';
 export * from './walker/index.js';
 export * from './set/index.js';
 export * from './display/index.js';
+export * from './compat/index.js';
 //# sourceMappingURL=index.js.map

package/dist/test/compat.d.ts

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

package/dist/test/compat.js

@@ -0,0 +1,11 @@
+import test from 'ava';
+// TODO: maybe nice to use for validate import { newSchemas } from './data/newSchemas.js'
+import { oldSchemas } from './data/oldSchemas.js';
+import { convertNewToOld, convertOldToNew } from '../src/index.js';
+test('old schema compat mode', async (t) => {
+    for (let i = 0; i < oldSchemas.length; i++) {
+        const oldSchema = oldSchemas[i];
+        t.deepEqual(convertNewToOld(convertOldToNew(oldSchema)), oldSchema, `Schema conversion oldSchemas index ${i}`);
+    }
+});
+//# sourceMappingURL=compat.js.map

package/dist/test/data/newSchemas.d.ts

@@ -0,0 +1,2 @@
+import { BasedSchema } from '../../src/types.js';
+export declare const newSchemas: BasedSchema[];

package/dist/test/data/newSchemas.js

@@ -0,0 +1,254 @@
+export const newSchemas = [
+    {
+        types: {
+            thing: {
+                prefix: 'ti',
+                fields: {
+                    priority: { type: 'number' },
+                    something: { type: 'string', format: 'strongPassword' },
+                },
+            },
+            bla: {
+                prefix: 'bl',
+                fields: {
+                    enum: {
+                        enum: ['tony', 'jim'],
+                    },
+                    setOfNumbers: {
+                        type: 'set',
+                        items: {
+                            type: 'number',
+                        },
+                    },
+                    object: {
+                        type: 'object',
+                        properties: {
+                            flap: { type: 'boolean' },
+                        },
+                    },
+                    flap: {
+                        type: 'boolean',
+                    },
+                    x: {
+                        type: 'object',
+                        properties: {
+                            flap: {
+                                type: 'boolean',
+                            },
+                        },
+                    },
+                    record: {
+                        type: 'record',
+                        values: {
+                            type: 'object',
+                            properties: {
+                                bla: {
+                                    type: 'array',
+                                    values: {
+                                        type: 'object',
+                                        properties: {
+                                            snux: {
+                                                type: 'object',
+                                                properties: {
+                                                    x: {
+                                                        type: 'number',
+                                                    },
+                                                },
+                                            },
+                                            flap: { type: 'number' },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                    bla: {
+                        type: 'set',
+                        items: { type: 'string', minLength: 3, maxLength: 6 },
+                    },
+                },
+            },
+        },
+        $defs: {},
+        language: 'en',
+        translations: ['de', 'nl', 'ro', 'za', 'ae'],
+        root: {
+            fields: {},
+        },
+        prefixToTypeMapping: {
+            bl: 'bla',
+            ti: 'thing',
+        },
+    },
+    {
+        types: {
+            thing: {
+                prefix: 'ti',
+                fields: {
+                    dateHuman: { type: 'timestamp', display: 'human' },
+                    dateTime: { type: 'timestamp', display: 'date-time' },
+                    dateTimeText: { type: 'timestamp', display: 'date-time-text' },
+                    time: { type: 'timestamp', display: 'time' },
+                    timePrecise: { type: 'timestamp', display: 'time-precise' },
+                    capitalize: {
+                        type: 'string',
+                        display: 'capitalize',
+                        format: 'lowercase',
+                    },
+                    upperCase: { type: 'string', display: 'uppercase' },
+                    lowerCase: { type: 'string', display: 'lowercase' },
+                    euros: { type: 'number', display: 'euro' },
+                    dollars: { type: 'number', display: 'dollar' },
+                    pounds: { type: 'number', display: 'pound' },
+                    bytes: { type: 'number', display: 'bytes' },
+                    humanNumber: { type: 'number', display: 'human' },
+                    ratio: { type: 'number', display: 'ratio' },
+                    short: { type: 'number', display: 'short' },
+                },
+            },
+        },
+        $defs: {},
+        language: 'en',
+        root: {
+            fields: {},
+        },
+        prefixToTypeMapping: {
+            bl: 'bla',
+            ti: 'thing',
+        },
+    },
+    {
+        language: 'en',
+        translations: ['nl'],
+        $defs: {},
+        prefixToTypeMapping: {},
+        root: {
+            fields: {},
+        },
+        types: {
+            file: {
+                prefix: 'fi',
+                fields: {
+                    usedIn: {
+                        type: 'references',
+                        bidirectional: { fromField: 'img' },
+                    },
+                    caption: {
+                        // needs translation?
+                        type: 'text',
+                        description: 'Caption for seo',
+                        title: 'Caption',
+                    },
+                },
+            },
+            user: {
+                prefix: 'us',
+                fields: {
+                    firstName: { type: 'string' },
+                    lastName: { type: 'string' },
+                    email: { type: 'string', format: 'email' },
+                    company: { type: 'reference' },
+                    newsletter: { type: 'integer' },
+                    ip: { type: 'string' },
+                    seen: { type: 'timestamp' },
+                    charges: {
+                        type: 'references',
+                        bidirectional: { fromField: 'user' },
+                        allowedTypes: ['charge'],
+                    },
+                    articles: {
+                        type: 'references',
+                        bidirectional: { fromField: 'contributors' },
+                        allowedTypes: ['article'],
+                    },
+                },
+            },
+            charge: {
+                fields: {
+                    // does this have a user?
+                    user: {
+                        type: 'reference',
+                        bidirectional: { fromField: 'charges' },
+                        allowedTypes: ['user'],
+                    },
+                    token: { type: 'string' },
+                    description: { type: 'string' },
+                    amount: { type: 'number' },
+                    stripeId: { type: 'string' },
+                },
+            },
+            category: {
+                fields: {
+                    title: { type: 'text' },
+                    children: {
+                        type: 'references',
+                        allowedTypes: ['article'],
+                    },
+                },
+            },
+            section: {
+                fields: {
+                    title: { type: 'text' },
+                    membership: { type: 'number' },
+                    membershipFreeDays: { type: 'number' },
+                    hidden: { type: 'boolean' },
+                    metaDescription: { type: 'text' },
+                    // meta_keywords: { type: 'array', values: { type: 'string' } },
+                    children: {
+                        type: 'references',
+                        allowedTypes: ['article', 'category'],
+                    },
+                },
+            },
+            article: {
+                prefix: 'ar',
+                fields: {
+                    contributors: {
+                        title: 'Writers',
+                        description: 'Writers or people involved with the article.',
+                        type: 'references',
+                        allowedTypes: ['user'],
+                        bidirectional: {
+                            fromField: 'articles',
+                        },
+                    },
+                    contributorsText: {
+                        title: 'Contributors text',
+                        description: 'Gets auto generated based on contributors, fill it in to override.',
+                        examples: ['Peter Teffer, graphics by Kashyap Raibagi (EDJNET)'],
+                        type: 'text',
+                    },
+                    headline: {
+                        title: 'Headline',
+                        description: 'Displayed on pages, also used as meta title for seo.',
+                        type: 'text',
+                    },
+                    publishDate: {
+                        title: 'Publish date',
+                        description: 'Any time you want the article to show on the website',
+                        type: 'timestamp',
+                    },
+                    archived: {
+                        title: 'Archived',
+                        description: 'Archived articles will not show up on the website or be available outside of the cms',
+                        type: 'boolean',
+                    },
+                    img: {
+                        type: 'reference',
+                        allowedTypes: ['file'],
+                        bidirectional: { fromField: 'usedIn' },
+                    },
+                    hits: { type: 'number' }, // get a bit more going here maybe? what does this mean
+                    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.',
+                    notes: { type: 'string' },
+                    abstract: { type: 'text' },
+                    body: { type: 'text', format: 'json' }, // will add rich text
+                },
+            },
+        },
+    },
+];
+//# sourceMappingURL=newSchemas.js.map

package/dist/test/data/oldSchemas.d.ts

@@ -0,0 +1,2 @@
+import { BasedOldSchema } from '../../src/compat/oldSchemaType.js';
+export declare const oldSchemas: BasedOldSchema[];