@based/schema 3.0.1 → 3.2.0

package/README.md

@@ -1,21 +1,2 @@
-# @based/functions
+# @based/schema
 
-To be used with based cloud functions, adds types and utilities.
-
-- Example based function
-
-```typescript
-import { BasedFunction } from '@based/functions'
-
-const submitVote: BasedFunction<
-  { target: number },
-  'ok' | 'not-ok'
-> = async (based, { target }) => {
-  if (target > 10) {
-    return 'ok'
-  }
-  return 'not-ok'
-}
-
-export default submitVote
-```

package/dist/src/compat/index.js

@@ -58,7 +58,7 @@ const convertOldToNewMeta = (props) => {
 };
 const convertNewFieldToOldField = (newField) => {
     // @ts-ignore
-    const { type, properties, values, items, ...props } = newField;
+    const { type, bidirectional, properties, values, items, ...props } = newField;
     const meta = convertNewToOldMeta(props);
     // @ts-ignore
     const overwrite = newToOldType[type] || newToOldType[props.format];
@@ -70,6 +70,10 @@ const convertNewFieldToOldField = (newField) => {
     if (meta) {
         oldField.meta = meta;
     }
+    if (bidirectional) {
+        // @ts-ignore
+        oldField.bidirectional = bidirectional;
+    }
     if (properties) {
         // @ts-ignore
         oldField.properties = {};
@@ -133,7 +137,7 @@ export const convertNewToOld = (newSchema) => {
 };
 const convertOldFieldToNewField = (oldField) => {
     // @ts-ignore
-    const { type, properties, values, items, meta = {} } = oldField;
+    const { type, bidirectional, properties, values, items, meta = {} } = oldField;
     const overwrite = oldToNewType[type] || oldToNewType[meta.format];
     const newField = overwrite
         ? {
@@ -144,6 +148,10 @@ const convertOldFieldToNewField = (oldField) => {
             type,
             ...convertOldToNewMeta(meta),
         };
+    if (bidirectional) {
+        // @ts-ignore
+        newField.bidirectional = bidirectional;
+    }
     if (properties) {
         // @ts-ignore
         newField.properties = {};

package/dist/src/generateQuery.d.ts

@@ -0,0 +1,12 @@
+import { BasedSchema, BasedSchemaField, BasedSchemaType } from './types.js';
+type Query = Record<string, any>;
+type Transformer = (Query: any, opts: {
+    type: string;
+    schema: BasedSchemaType;
+    depth: number;
+}) => Query;
+export declare const generateQueryForType: (type: string, schema: BasedSchema, depth?: number, transformer?: Transformer, query?: Query, nestedRefs?: Set<BasedSchemaField>) => Query;
+export declare const generateQuery: (query: {
+    $id: string;
+} & Query, schema: BasedSchema, depth?: number, transformer?: Transformer) => Query;
+export {};

package/dist/src/generateQuery.js

@@ -0,0 +1,75 @@
+const parseSchemaField = (schemaField, schema, depth, transformer, nestedRefs, currentQuery) => {
+    if ('values' in schemaField) {
+        return parseSchemaField(schemaField.values, schema, depth, transformer, nestedRefs, currentQuery);
+    }
+    if ('items' in schemaField) {
+        return parseSchemaField(schemaField.items, schema, depth, transformer, nestedRefs, currentQuery);
+    }
+    if ('properties' in schemaField) {
+        currentQuery ??= {};
+        for (const i in schemaField.properties) {
+            const v = currentQuery[i];
+            if (v === true || v === false) {
+                continue;
+            }
+            currentQuery[i] = parseSchemaField(schemaField.properties[i], schema, depth, transformer, nestedRefs, currentQuery[i]);
+        }
+        return currentQuery;
+    }
+    if (schemaField.type === 'reference' || schemaField.type === 'references') {
+        const nestedDepth = depth - 1;
+        if (nestedDepth < 0) {
+            return true;
+        }
+        if (nestedRefs) {
+            if (nestedRefs.has(schemaField)) {
+                return true;
+            }
+            nestedRefs.add(schemaField);
+        }
+        const allowedTypes = schemaField.allowedTypes?.length
+            ? schemaField.allowedTypes
+            : Object.keys(schema.types);
+        for (const i of allowedTypes) {
+            currentQuery = generateQueryForType(typeof i === 'string' ? i : i.type, schema, nestedDepth, transformer, currentQuery, nestedRefs || new Set([schemaField]));
+        }
+        if (schemaField.type === 'references') {
+            currentQuery.$list = true;
+        }
+        return currentQuery;
+    }
+    return true;
+};
+export const generateQueryForType = (type, schema, depth = 0, transformer, query = {}, nestedRefs) => {
+    const schemaType = type === 'root' ? schema.root : schema.types[type];
+    if (!schemaType) {
+        throw new Error('unknown type');
+    }
+    query.id ??= true;
+    query.type ??= true;
+    query.createdAt ??= true;
+    query.updatedAt ??= true;
+    if (schemaType.fields) {
+        for (const key in schemaType.fields) {
+            const v = query[key];
+            if (v === true || v === false) {
+                continue;
+            }
+            const schemaField = schemaType.fields[key];
+            query[key] = parseSchemaField(schemaField, schema, depth, transformer, nestedRefs, query[key]);
+        }
+    }
+    return transformer
+        ? transformer(query, { type, depth, schema: schemaType })
+        : query;
+};
+export const generateQuery = (query, schema, depth, transformer) => {
+    const type = query.$id === 'root'
+        ? query.$id
+        : schema.prefixToTypeMapping[query.$id.substring(0, 2)];
+    if (!type) {
+        throw new Error('invalid type');
+    }
+    return generateQueryForType(type, schema, depth, transformer, query);
+};
+//# sourceMappingURL=generateQuery.js.map

package/dist/src/set/fields/references.js

@@ -86,6 +86,36 @@ export const reference = async (args) => {
         args.error(ParseError.referenceIsIncorrectType);
     }
 };
+function parseSortableOp(args, value, op) {
+    if (typeof value[op] !== 'object') {
+        args.error(ParseError.incorrectFormat);
+        return;
+    }
+    if (!args.fieldSchema.sortable) {
+        args.error(ParseError.incorrectFieldType);
+        return;
+    }
+    switch (typeof value[op].$idx) {
+        case 'bigint':
+            break;
+        case 'number':
+            value[op].$idx = BigInt(value[op].$idx);
+            break;
+        default:
+            args.error(ParseError.incorrectFormat);
+            return;
+    }
+    if (Array.isArray(value[op].$value)) {
+        // NOP
+    }
+    else if (typeof value[op].$value === 'string') {
+        value[op].$value = [value[op].$value];
+    }
+    else {
+        args.error(ParseError.incorrectFormat);
+        return;
+    }
+}
 export const references = async (args) => {
     const { value } = args;
     if (typeof value !== 'object' || value === null) {
@@ -113,6 +143,16 @@ export const references = async (args) => {
             else if (key === '$remove') {
                 args.value.$remove = await parseOperator(args, key);
             }
+            else if (key === '$assign') {
+                parseSortableOp(args, value, '$assign');
+            }
+            else if (key === '$insert') {
+                parseSortableOp(args, value, '$insert');
+            }
+            else if (key === '$move') {
+                parseSortableOp(args, value, '$move');
+                value.$move.$value.reverse();
+            }
             else {
                 args.create({ key }).error(ParseError.fieldDoesNotExist);
             }

package/dist/src/set/fields/string.js

@@ -74,6 +74,7 @@ const formatPatterns = {
     clike: () => true,
     // Can add some more checks for this...
     basedId: (value) => typeof value === 'string' && value.length < 16,
+    basedType: (value) => typeof value === 'string' && value.length < 64,
 };
 const validateString = (args, value) => {
     if (typeof value !== 'string') {

package/dist/src/types.d.ts

@@ -43,7 +43,7 @@ export type BasedSchemaFieldShared = {
     };
     $delete?: boolean;
 };
-export declare const basedSchemaStringFormatValues: readonly ["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", "code", "typescript", "javascript", "python", "rust", "css", "html", "json", "markdown", "clike", "basedId"];
+export declare const basedSchemaStringFormatValues: readonly ["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", "code", "typescript", "javascript", "python", "rust", "css", "html", "json", "markdown", "clike", "basedId", "basedType"];
 export type BasedSchemaStringShared = {
     minLength?: number;
     maxLength?: number;

package/dist/src/types.js

@@ -94,5 +94,6 @@ export const basedSchemaStringFormatValues = [
     'markdown',
     'clike',
     'basedId',
+    'basedType',
 ];
 //# sourceMappingURL=types.js.map

package/dist/test/compat.js

@@ -50,6 +50,31 @@ test('refTypes', async (t) => {
     // @ts-ignore
     t.is(oldSchema.types.youzi.fields.image.meta.refTypes[0], 'youzi');
 });
+test('bidirectional', async (t) => {
+    const newSchema = convertOldToNew({
+        types: {
+            youzi: {
+                fields: {
+                    image: {
+                        type: 'reference',
+                        bidirectional: {
+                            fromField: 'success',
+                        },
+                        meta: {
+                            refTypes: ['youzi'],
+                        },
+                    },
+                },
+            },
+        },
+    });
+    console.log(newSchema.types.youzi.fields.image);
+    // @ts-ignore
+    t.is(newSchema.types.youzi.fields.image.bidirectional.fromField, 'success');
+    const oldSchema = convertNewToOld(newSchema);
+    // @ts-ignore
+    t.is(oldSchema.types.youzi.fields.image.bidirectional.fromField, 'success');
+});
 test('old schema compat mode', async (t) => {
     for (let i = 0; i < oldSchemas.length - 1; i++) {
         const oldSchema = oldSchemas[i];

package/dist/test/query.d.ts

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

package/dist/test/query.js

@@ -0,0 +1,93 @@
+import test from 'ava';
+import { generateQuery } from '../src/generateQuery.js';
+const schema = {
+    types: {
+        thing: {
+            prefix: 'ti',
+            fields: {
+                priority: { type: 'number' },
+                something: { type: 'string', format: 'strongPassword' },
+                blaRef: {
+                    type: 'reference',
+                    allowedTypes: ['bla'],
+                },
+            },
+        },
+        bla: {
+            prefix: 'bl',
+            fields: {
+                arr: {
+                    type: 'array',
+                    items: {
+                        type: 'string',
+                    },
+                },
+                refArr: {
+                    type: 'array',
+                    items: {
+                        type: 'reference',
+                    },
+                },
+                refRec: {
+                    type: 'record',
+                    values: {
+                        type: 'reference',
+                    },
+                },
+                obj: {
+                    type: 'object',
+                    properties: {
+                        blafurp: { type: 'string' },
+                        nesto: {
+                            type: 'object',
+                            properties: {
+                                nestfield: { type: 'string' },
+                            },
+                        },
+                        reffie: { type: 'reference' },
+                    },
+                },
+                ref: {
+                    type: 'reference',
+                },
+                children: {
+                    type: 'references',
+                },
+                referencesToThings: {
+                    type: 'references',
+                    allowedTypes: ['thing'],
+                },
+                referenceToThing: {
+                    type: 'reference',
+                    allowedTypes: ['thing'],
+                },
+            },
+        },
+    },
+    $defs: {},
+    language: 'en',
+    translations: ['de', 'nl', 'ro', 'za', 'ae'],
+    root: {
+        fields: {},
+    },
+    prefixToTypeMapping: {
+        bl: 'bla',
+        ti: 'thing',
+    },
+};
+test('generate query', async (t) => {
+    const query = generateQuery({
+        $id: 'bl1',
+        $language: 'en',
+        children: {
+            id: false,
+        },
+        refArr: {
+            id: false,
+            obj: false,
+        },
+    }, schema, 1);
+    console.dir(query, { depth: null });
+    t.pass();
+});
+//# sourceMappingURL=query.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@based/schema",
-  "version": "3.0.1",
+  "version": "3.2.0",
   "license": "MIT",
   "main": "dist/src/index.js",
   "files": [