@based/schema 3.1.0 → 4.1.0

package/dist/test/compat.js

@@ -45,11 +45,36 @@ test('refTypes', async (t) => {
         },
     });
     // @ts-ignore
-    t.is(newSchema.types.youzi.fields.image.allowedTypes[0], 'youzi');
+    t.is(newSchema.types.youzi.fields.image.allowedType, 'youzi');
     const oldSchema = convertNewToOld(newSchema);
     // @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/data/newSchemas.js

@@ -65,7 +65,7 @@ const testSchema = {
                 },
                 winner: {
                     type: 'reference',
-                    allowedTypes: ['contestant'],
+                    allowedType: 'contestant',
                 },
                 countries: {
                     type: 'references',
@@ -87,7 +87,7 @@ const testSchema = {
                 },
                 image: {
                     type: 'reference',
-                    allowedTypes: ['file'],
+                    allowedType: 'file',
                 },
                 startTime: {
                     type: 'timestamp',
@@ -99,11 +99,11 @@ const testSchema = {
                 },
                 producer: {
                     type: 'reference',
-                    allowedTypes: ['broadcaster'],
+                    allowedType: 'broadcaster',
                 },
                 distributors: {
                     type: 'references',
-                    allowedTypes: ['broadcaster'],
+                    allowedType: 'broadcaster',
                 },
             },
         },
@@ -141,7 +141,7 @@ const testSchema = {
                 },
                 image: {
                     type: 'reference',
-                    allowedTypes: ['file'],
+                    allowedType: 'file',
                 },
                 content: {
                     type: 'text',
@@ -162,7 +162,7 @@ const testSchema = {
                 },
                 image: {
                     type: 'reference',
-                    allowedTypes: ['file'],
+                    allowedType: 'file',
                 },
             },
         },
@@ -368,7 +368,7 @@ export const newSchemas = [
                 fields: {
                     usedIn: {
                         type: 'references',
-                        bidirectional: { fromField: 'img' },
+                        inverseProperty: 'img',
                     },
                     caption: {
                         // needs translation?
@@ -390,13 +390,13 @@ export const newSchemas = [
                     seen: { type: 'timestamp' },
                     charges: {
                         type: 'references',
-                        bidirectional: { fromField: 'user' },
-                        allowedTypes: ['charge'],
+                        inverseProperty: 'user',
+                        allowedType: 'charge',
                     },
                     articles: {
                         type: 'references',
-                        bidirectional: { fromField: 'contributors' },
-                        allowedTypes: ['article'],
+                        inverseProperty: 'contributors',
+                        allowedType: 'article',
                     },
                 },
             },
@@ -405,8 +405,8 @@ export const newSchemas = [
                     // does this have a user?
                     user: {
                         type: 'reference',
-                        bidirectional: { fromField: 'charges' },
-                        allowedTypes: ['user'],
+                        inverseProperty: 'charges',
+                        allowedType: 'user',
                     },
                     token: { type: 'string' },
                     description: { type: 'string' },
@@ -419,7 +419,7 @@ export const newSchemas = [
                     title: { type: 'text' },
                     children: {
                         type: 'references',
-                        allowedTypes: ['article'],
+                        allowedType: 'article',
                     },
                 },
             },
@@ -433,7 +433,7 @@ export const newSchemas = [
                     // meta_keywords: { type: 'array', values: { type: 'string' } },
                     children: {
                         type: 'references',
-                        allowedTypes: ['article', 'category'],
+                        allowedType: 'article' // FIXME Can't have both 'category'],
                     },
                 },
             },
@@ -444,10 +444,8 @@ export const newSchemas = [
                         title: 'Writers',
                         description: 'Writers or people involved with the article.',
                         type: 'references',
-                        allowedTypes: ['user'],
-                        bidirectional: {
-                            fromField: 'articles',
-                        },
+                        allowedType: 'user',
+                        inverseProperty: 'articles',
                     },
                     contributorsText: {
                         title: 'Contributors text',
@@ -472,8 +470,8 @@ export const newSchemas = [
                     },
                     img: {
                         type: 'reference',
-                        allowedTypes: ['file'],
-                        bidirectional: { fromField: 'usedIn' },
+                        allowedType: 'file',
+                        inverseProperty: 'usedIn',
                     },
                     hits: { type: 'number' }, // get a bit more going here maybe? what does this mean
                     // membership: { enum: ['Need membership', 'Free'] },

package/dist/test/reference.js

@@ -15,17 +15,19 @@ const schema = {
             fields: {
                 ref: {
                     type: 'reference',
+                    allowedType: 'bla',
                 },
                 children: {
                     type: 'references',
+                    allowedType: 'bla',
                 },
                 referencesToThings: {
                     type: 'references',
-                    allowedTypes: ['thing'],
+                    allowedType: 'thing',
                 },
                 referenceToThing: {
                     type: 'reference',
-                    allowedTypes: ['thing'],
+                    allowedType: 'thing',
                 },
             },
         },

package/dist/test/walker.js

@@ -14,11 +14,11 @@ const schema = {
             fields: {
                 referencesToThings: {
                     type: 'references',
-                    allowedTypes: ['thing'],
+                    allowedType: 'thing',
                 },
                 referenceToThing: {
                     type: 'reference',
-                    allowedTypes: ['thing'],
+                    allowedType: 'thing',
                 },
                 enum: {
                     enum: ['tony', 'jim'],

package/dist/types.d.ts

@@ -0,0 +1,140 @@
+type Letter = 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z' | 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z';
+type QueryFn = Function;
+type PropValues = {
+    type?: string;
+    default?: any;
+};
+type Prop<V extends PropValues> = {
+    required?: boolean;
+    label?: Record<string, string>;
+    description?: Record<string, string>;
+    path?: string;
+    query?: QueryFn;
+} & V;
+type EnumItem = string | number | boolean;
+export type SchemaReferences = Prop<{
+    type?: 'references';
+    items: SchemaReference;
+}>;
+export type SchemaReferencesOneWay = Prop<{
+    type?: 'references';
+    items: SchemaReferenceOneWay;
+}>;
+export type SchemaText = Prop<{
+    type: 'text';
+    default?: Record<string, string>;
+}>;
+type NumberType = 'number' | 'int8' | 'uint8' | 'int16' | 'uint16' | 'int32' | 'uint32';
+export type SchemaNumber = Prop<{
+    type: NumberType;
+    default?: number;
+    min?: number;
+    max?: number;
+    step?: number | 'any';
+}>;
+export type SchemaString = Prop<{
+    type: 'string';
+    default?: string;
+    maxBytes?: number;
+    max?: number;
+    min?: number;
+}>;
+export type SchemaBinary = Prop<{
+    type: 'binary';
+    default?: ArrayBuffer;
+    maxBytes?: number;
+}>;
+export type SchemaBoolean = Prop<{
+    type: 'boolean';
+    default?: boolean;
+}>;
+export type SchemaTimestamp = Prop<{
+    type: 'timestamp';
+    default?: number | Date;
+    on?: 'create' | 'update';
+}>;
+export type SchemaReferenceOneWay = Prop<{
+    type?: 'reference';
+    default?: string;
+    ref: string;
+}>;
+export type SchemaReference = Prop<{
+    type?: 'reference';
+    default?: string;
+    ref: string;
+    prop: string;
+}> & Record<`$${string}`, SchemaPropOneWay>;
+export type SchemaObject = Prop<{
+    type?: 'object';
+    props: SchemaProps;
+}>;
+export type SchemaObjectOneWay = Prop<{
+    type?: 'object';
+    props: SchemaPropsOneWay;
+}>;
+export type SchemaReferenceWithQuery = SchemaReferenceOneWay & {
+    query: QueryFn;
+};
+export type SchemaReferencesWithQuery = SchemaReferencesOneWay & {
+    query: QueryFn;
+};
+export type SchemaEnum = Prop<{
+    type?: 'enum';
+    default?: EnumItem;
+    enum: EnumItem[];
+}>;
+export type SchemaAlias = SchemaString & {
+    type: 'alias';
+};
+export type SchemaPropShorthand = 'timestamp' | 'boolean' | 'string' | 'alias' | 'text' | NumberType | EnumItem[];
+type SetItems = SchemaPropShorthand | SchemaTimestamp | SchemaBoolean | SchemaNumber | SchemaString | SchemaEnum;
+export type SchemaSet<ItemsType extends SetItems = SetItems> = Prop<{
+    type?: 'set';
+    default?: ItemsType extends {
+        default: any;
+    } ? ItemsType['default'][] : undefined;
+    items: ItemsType;
+}>;
+type NonRefSchemaProps = SchemaPropShorthand | SchemaTimestamp | SchemaBoolean | SchemaNumber | SchemaString | SchemaAlias | SchemaText | SchemaEnum | SchemaSet;
+export type SchemaProp = SchemaReferencesWithQuery | SchemaReferenceWithQuery | NonRefSchemaProps | SchemaReferences | SchemaReference | SchemaObject | SchemaBinary;
+export type SchemaPropOneWay = SchemaReferencesOneWay | SchemaReferenceOneWay | SchemaObjectOneWay | NonRefSchemaProps;
+export type SchemaAnyProp = SchemaPropOneWay | SchemaProp;
+export type SchemaHook = string | Function;
+export type SchemaProps = Record<string, SchemaProp>;
+export type SchemaType = {
+    hooks?: {
+        create?: SchemaHook;
+        update?: SchemaHook;
+        delete?: SchemaHook;
+    };
+    id?: number;
+    props: SchemaProps;
+};
+export type SchemaTypes = Record<string, SchemaType>;
+export type SchemaPropsOneWay = Record<`${Letter}${string}`, SchemaPropOneWay>;
+export type Schema = {
+    types?: SchemaTypes;
+    props?: SchemaPropsOneWay;
+    locales?: SchemaLocales;
+};
+export type SchemaLocales = Record<string, {
+    required?: boolean;
+    fallback?: string[];
+}>;
+export type SchemaPropTypeMap = {
+    references: SchemaReferences;
+    timestamp: SchemaTimestamp;
+    reference: SchemaReference;
+    boolean: SchemaBoolean;
+    string: SchemaString;
+    object: SchemaObject;
+    alias: SchemaAlias;
+    enum: SchemaEnum;
+    text: SchemaText;
+    set: SchemaSet;
+    binary: SchemaBinary;
+} & Record<NumberType, SchemaNumber>;
+export type SchemaPropTypes = keyof SchemaPropTypeMap;
+export declare const isPropType: <T extends "string" | "boolean" | "object" | "references" | "timestamp" | "alias" | "text" | NumberType | "binary" | "reference" | "enum" | "set">(type: T, prop: SchemaProp) => prop is SchemaPropTypeMap[T];
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -0,0 +1,5 @@
+import { getPropType } from './parse/utils.js';
+export const isPropType = (type, prop) => {
+    return getPropType(prop) === type;
+};
+//# sourceMappingURL=types.js.map

package/package.json

@@ -1,41 +1,30 @@
 {
   "name": "@based/schema",
-  "version": "3.1.0",
+  "version": "4.1.0",
   "license": "MIT",
-  "main": "dist/src/index.js",
+  "main": "dist/index.js",
   "files": [
     "dist",
     "README.md",
     "package.json",
-    "!dist/**/*.js.map"
+    "!dist/**/*.map"
   ],
   "scripts": {
-    "build": "npx tsc",
-    "watch": "npx tsc --watch",
-    "clean": "rimraf {.turbo,dist,node_modules}",
-    "test": "ava --color --timeout 3m --verbose",
-    "test-ci": "ava --color --concurrency 1 --timeout 3m"
+    "build": "tsc",
+    "watch": "tsc --watch",
+    "test": "tsc && tsc test/*.ts --noEmit && tsx --test test/*.ts"
   },
+  "prettier": "@saulx/prettier-config",
   "sideEffects": false,
   "type": "module",
-  "dependencies": {
-    "validator": "^13.9.0",
-    "@saulx/hash": "^2.0.0",
-    "@saulx/utils": "^3.5.0"
-  },
-  "ava": {
-    "timeout": "2m",
-    "files": [
-      "./dist/test/*.js",
-      "./dist/test/validateSchema/*.js"
-    ]
-  },
   "devDependencies": {
-    "type-fest": "^3.12.0",
+    "@saulx/prettier-config": "2.0.0",
     "@saulx/tsconfig": "^1.1.0",
-    "ts-node": "10.9.1",
-    "typescript": "^5.1.6",
-    "rimraf": "^3.0.2",
-    "ava": "6.1.1"
+    "@types/node": "22.5.3",
+    "tsx": "^4.19.0",
+    "typescript": "^5.1.6"
+  },
+  "dependencies": {
+    "picocolors": "^1.1.0"
   }
 }

package/README.md

@@ -1,21 +0,0 @@
-# @based/functions
-
-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/newToOld.d.ts

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

package/dist/src/compat/newToOld.js

@@ -1,76 +0,0 @@
-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/oldToNew.d.ts

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

package/dist/src/compat/oldToNew.js

@@ -1,35 +0,0 @@
-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