@based/schema 3.2.0 → 4.1.0

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

@@ -1,205 +1,140 @@
-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 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;
-    $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 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';
-} & 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 = {
+    default?: string;
+    maxBytes?: number;
+    max?: number;
+    min?: number;
+}>;
+export type SchemaBinary = Prop<{
+    type: 'binary';
+    default?: ArrayBuffer;
+    maxBytes?: number;
+}>;
+export type SchemaBoolean = Prop<{
     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;
+    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 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 SchemaReferencesWithQuery = SchemaReferencesOneWay & {
+    query: QueryFn;
 };
-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 SchemaEnum = Prop<{
+    type?: 'enum';
+    default?: EnumItem;
+    enum: EnumItem[];
+}>;
+export type SchemaAlias = SchemaString & {
+    type: 'alias';
 };
-export type BasedSchemaCollectProps = ArgsClass<BasedSetTarget> & {
-    root: ArgsClass<BasedSetTarget> & {
-        typeSchema: BasedSchemaType;
+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

@@ -1,27 +1,5 @@
-"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';
+import { getPropType } from './parse/utils.js';
+export const isPropType = (type, prop) => {
+    return getPropType(prop) === type;
 };
-exports.isCollection = isCollection;
-exports.languages = Object.keys(languages_1.languages);
 //# sourceMappingURL=types.js.map

package/package.json

@@ -1,41 +1,30 @@
 {
   "name": "@based/schema",
-  "version": "3.2.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,2 +0,0 @@
-# @based/schema
-

package/dist/display/index.d.ts

@@ -1,2 +0,0 @@
-import { BasedSchemaField } from '../types';
-export declare const display: (value: string | number | void, field: BasedSchemaField) => string | number | void;

package/dist/display/index.js

@@ -1,26 +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.display = void 0;
-const timestamp_1 = __importDefault(require("./timestamp"));
-const number_1 = __importDefault(require("./number"));
-const string_1 = __importDefault(require("./string"));
-const display = (value, field) => {
-    if (field.type === 'timestamp' && typeof value === 'number') {
-        // @ts-ignore
-        return (0, timestamp_1.default)(value, field.display);
-    }
-    if (field.type === 'number' && typeof value === 'number') {
-        // @ts-ignore
-        return (0, number_1.default)(value, field.display);
-    }
-    if (field.type === 'string' && typeof value === 'string') {
-        // @ts-ignore
-        return (0, string_1.default)(value, field.display);
-    }
-    return value;
-};
-exports.display = display;
-//# sourceMappingURL=index.js.map

package/dist/display/number.d.ts

@@ -1,3 +0,0 @@
-export type NumberFormat = 'short' | 'human' | 'ratio' | 'bytes' | 'euro' | 'dollar' | 'pound' | `round-${number}`;
-declare const parseNumber: (nr: number | string, format?: NumberFormat) => string | number;
-export default parseNumber;