yuppi 1.3.22 → 1.4.0

package/README.md

@@ -65,7 +65,7 @@ Schemas that can be converted to Yup and JSON Schema.
 - Portable schemas as a JSON file
 - Works with Yup, stable and secure
 - Schemas can be declared for TypeScript
-- It is strict and therefore does not accept more than one type
+- It has union support, properties can have multiple types
 - Error messages are ready to be understood but can be edited if desired
 - Can be converted to Yup and [JSON Schema](https://json-schema.org). JSON Schema is OpenAPI compatible
 
@@ -185,13 +185,34 @@ Validate the properties with your Yuppi schema.
 >     lowercase: true,
 >     nullable: false,
 >     required: true
->   }
+>   },
+>
+>   permissions: [
+>     {
+>       type: 'string',
+>       enum: ['*'],
+>       nullable: false,
+>       required: true
+>     },
+>     {
+>       type: 'array',
+>       items: {
+>         type: 'string',
+>         enum: ['read', 'write'],
+>         nullable: false,
+>         required: true
+>       },
+>       nullable: false,
+>       required: true
+>     }
+>   ]
 > };
 >
 > const properties = {
 >   display_name: 'Fırat',
 >   username: 'fir4tozden',
->   email: 'fir4tozden@gmail.com'
+>   email: 'fir4tozden@gmail.com',
+>   permissions: '*'
 > };
 >
 > try {
@@ -200,7 +221,8 @@ Validate the properties with your Yuppi schema.
 >     {
 >       display_name: "Fırat",
 >       username: "fir4tozden",
->       email: "fir4tozden@gmail.com"
+>       email: "fir4tozden@gmail.com",
+>       permissions: "*"
 >     }
 >   */
 > } catch (error) {
@@ -236,6 +258,7 @@ Declare your Yuppi schema for TypeScript.
 >     display_name: string;
 >     username: string;
 >     email: string;
+>     permissions: "*" | ("read" | "write")[];
 >   }
 > */
 > ```
@@ -291,11 +314,26 @@ Convert your Yuppi schema into [JSON Schema](https://json-schema.org).
 >       email: {
 >         type: "string",
 >         pattern: "^[a-zA-Z0-9._-]+@([a-zA-Z0-9-]+\\.)+[a-zA-Z]{2,}$"
+>       },
+>       permissions: {
+>         anyOf: [
+>           {
+>             type: "string",
+>             enum: ["*"]
+>           },
+>           {
+>             type: "array",
+>             items: {
+>               type: "string",
+>               enum: ["read", "write"]
+>             }
+>           }
+>         ]
 >       }
 >     },
->     required: [ "display_name", "username", "email" ],
+>     required: ["display_name", "username", "email", "permissions"],
 >     additionalProperties: false
->   }
+>   };
 > */
 > ```
 

package/dist/main.d.mts

@@ -60,7 +60,9 @@ type Array = {
     nullable: boolean;
     required: boolean;
 };
-type Types = String | Number | Boolean | Date | Object$1 | Array;
+type Type = String | Number | Boolean | Date | Object$1 | Array;
+type Union = [Type, Type, ...Type[]];
+type Types = Type | Union;
 type Schema = Record<string, Types>;
 
 type YuppiOptions = {
@@ -109,6 +111,7 @@ type YuppiOptions = {
 declare class Yuppi {
     private readonly options;
     constructor(options?: YuppiOptions);
+    private cleanupTypesDir;
     validate(schema: Schema, properties: AnyObject): Promise<{
         [x: string]: any;
         [x: number]: any;

package/dist/main.d.ts

@@ -60,7 +60,9 @@ type Array = {
     nullable: boolean;
     required: boolean;
 };
-type Types = String | Number | Boolean | Date | Object$1 | Array;
+type Type = String | Number | Boolean | Date | Object$1 | Array;
+type Union = [Type, Type, ...Type[]];
+type Types = Type | Union;
 type Schema = Record<string, Types>;
 
 type YuppiOptions = {
@@ -109,6 +111,7 @@ type YuppiOptions = {
 declare class Yuppi {
     private readonly options;
     constructor(options?: YuppiOptions);
+    private cleanupTypesDir;
     validate(schema: Schema, properties: AnyObject): Promise<{
         [x: string]: any;
         [x: number]: any;

package/dist/main.js

@@ -49,7 +49,7 @@ var convertToJSONSchema = (schema, options) => {
     if (!config.required) schema2 = import_typebox.Type.Optional(schema2);
     return schema2;
   };
-  const build = (key, config) => {
+  const buildSingle = (key, config) => {
     let schema2;
     if (config.type === "string") {
       schema2 = import_typebox.Type.String({ enum: config.enum, minLength: config.min, maxLength: config.max, pattern: config.pattern !== void 0 ? new RegExp(config.pattern).source : void 0, default: config.default });
@@ -83,6 +83,13 @@ var convertToJSONSchema = (schema, options) => {
       return schema2;
     } else throw new Error(`Unsupported schema type for ${key}`);
   };
+  const build = (key, config) => {
+    if (!Array.isArray(config)) return buildSingle(key, config);
+    const schemas = config.map((config2) => buildSingle(key, config2));
+    const optional = config.every((config2) => !config2.required);
+    const union_schema = import_typebox.Type.Union(schemas);
+    return optional ? import_typebox.Type.Optional(union_schema) : union_schema;
+  };
   const properties = {};
   for (const [key, config] of Object.entries(schema)) properties[key] = build(key, config);
   return import_typebox.Type.Object(properties, { additionalProperties: !(options.validate_options?.stripUnknown ?? false) });
@@ -92,6 +99,7 @@ var convertToJSONSchema = (schema, options) => {
 var Yup = __toESM(require("yup"));
 var convertToYup = (schema, options) => {
   const base = (schema2, key, config) => {
+    schema2 = schema2.strict();
     schema2 = schema2.nullable();
     schema2 = schema2.optional();
     if (config.default !== void 0) schema2 = schema2.default(config.default);
@@ -108,7 +116,7 @@ var convertToYup = (schema, options) => {
       );
     return schema2;
   };
-  const build = (key, config) => {
+  const buildSingle = (key, config) => {
     let schema2;
     if (config.type === "string") {
       schema2 = Yup.string().typeError(({ path: path2 }) => (options.error_messages?.string?.type ?? "").replaceAll("{path}", path2));
@@ -152,6 +160,7 @@ var convertToYup = (schema, options) => {
       if (config.min !== void 0) schema2 = schema2.min(config.min, ({ path: path2, min }) => (options.error_messages?.date?.min ?? "").replaceAll("{path}", path2).replaceAll("{min}", new Date(min).toISOString()));
       if (config.max !== void 0) schema2 = schema2.max(config.max, ({ path: path2, max }) => (options.error_messages?.date?.max ?? "").replaceAll("{path}", path2).replaceAll("{max}", new Date(max).toISOString()));
       schema2 = base(schema2, key, config);
+      schema2 = schema2.strict(false);
       return schema2;
     } else if (config.type === "object") {
       schema2 = Yup.object().typeError(({ path: path2 }) => (options.error_messages?.object?.type ?? "").replaceAll("{path}", path2));
@@ -175,7 +184,15 @@ var convertToYup = (schema, options) => {
       schema2 = schema2.of(build(key, config.items));
       schema2 = base(schema2, key, config);
       return schema2;
-    } else throw new Error(`Unsupported schema type for ${key}`);
+    }
+  };
+  const build = (key, config) => {
+    if (!Array.isArray(config)) return buildSingle(key, config);
+    const schemas = config.map((config2) => buildSingle(key, config2));
+    return Yup.lazy((property) => {
+      for (const schema2 of schemas) if (schema2.isValidSync(property)) return schema2;
+      return buildSingle(key, config[0]);
+    });
   };
   const properties = {};
   for (const [key, config] of Object.entries(schema)) properties[key] = build(key, config);
@@ -235,10 +252,28 @@ var YuppiOptionsDefault = {
 };
 
 // src/Yuppi.class.ts
+var cleaned_types_dirs = /* @__PURE__ */ new Set();
 var Yuppi = class {
   options;
   constructor(options = YuppiOptionsDefault) {
     this.options = (0, import_lodash.default)({}, YuppiOptionsDefault, options);
+    void this.cleanupTypesDir();
+  }
+  async cleanupTypesDir() {
+    const types_dir = import_path.default.join(this.options.output_dir ?? "./", "types");
+    const exists = async (path2) => {
+      try {
+        await import_promises.default.access(path2, import_promises.default.constants.F_OK);
+        return true;
+      } catch {
+        return false;
+      }
+    };
+    if (await exists(types_dir) && !cleaned_types_dirs.has(types_dir)) {
+      cleaned_types_dirs.add(types_dir);
+      await import_promises.default.rm(types_dir, { recursive: true, force: true });
+      await import_promises.default.mkdir(types_dir, { recursive: true });
+    }
   }
   validate(schema, properties) {
     const yup_schema = this.convertToYup(schema);

package/dist/main.mjs

@@ -11,17 +11,17 @@ import fs from "fs/promises";
 import path from "path";
 
 // src/utils/ConvertToJSONSchema.util.ts
-import { Type } from "@sinclair/typebox";
+import { Type as Typebox } from "@sinclair/typebox";
 var convertToJSONSchema = (schema, options) => {
   const base = (schema2, key, config) => {
-    if (config.nullable || config.default === null) schema2 = Type.Union([schema2, Type.Null()]);
-    if (!config.required) schema2 = Type.Optional(schema2);
+    if (config.nullable || config.default === null) schema2 = Typebox.Union([schema2, Typebox.Null()]);
+    if (!config.required) schema2 = Typebox.Optional(schema2);
     return schema2;
   };
-  const build = (key, config) => {
+  const buildSingle = (key, config) => {
     let schema2;
     if (config.type === "string") {
-      schema2 = Type.String({ enum: config.enum, minLength: config.min, maxLength: config.max, pattern: config.pattern !== void 0 ? new RegExp(config.pattern).source : void 0, default: config.default });
+      schema2 = Typebox.String({ enum: config.enum, minLength: config.min, maxLength: config.max, pattern: config.pattern !== void 0 ? new RegExp(config.pattern).source : void 0, default: config.default });
       schema2 = base(schema2, key, config);
       return schema2;
     } else if (config.type === "number") {
@@ -29,38 +29,46 @@ var convertToJSONSchema = (schema, options) => {
       let exclusive_maximum;
       if (config.positive === true && config.min === void 0) exclusive_minimum = 0;
       if (config.negative === true && config.max === void 0) exclusive_maximum = 0;
-      schema2 = config.integer === true ? Type.Integer({ enum: config.enum, minimum: config.min, maximum: config.max, exclusiveMinimum: exclusive_minimum, exclusiveMaximum: exclusive_maximum, positive: config.positive, negative: config.negative, default: config.default }) : Type.Number({ enum: config.enum, minimum: config.min, maximum: config.max, exclusiveMinimum: exclusive_minimum, exclusiveMaximum: exclusive_maximum, positive: config.positive, negative: config.negative, default: config.default });
+      schema2 = config.integer === true ? Typebox.Integer({ enum: config.enum, minimum: config.min, maximum: config.max, exclusiveMinimum: exclusive_minimum, exclusiveMaximum: exclusive_maximum, positive: config.positive, negative: config.negative, default: config.default }) : Typebox.Number({ enum: config.enum, minimum: config.min, maximum: config.max, exclusiveMinimum: exclusive_minimum, exclusiveMaximum: exclusive_maximum, positive: config.positive, negative: config.negative, default: config.default });
       schema2 = base(schema2, key, config);
       return schema2;
     } else if (config.type === "boolean") {
-      schema2 = Type.Boolean({ default: config.default });
+      schema2 = Typebox.Boolean({ default: config.default });
       schema2 = base(schema2, key, config);
       return schema2;
     } else if (config.type === "date") {
-      schema2 = Type.String({ format: "date-time", formatMinimum: config.min !== void 0 ? new Date(config.min).toISOString() : void 0, formatMaximum: config.max !== void 0 ? new Date(config.max).toISOString() : void 0, default: config.default });
+      schema2 = Typebox.String({ format: "date-time", formatMinimum: config.min !== void 0 ? new Date(config.min).toISOString() : void 0, formatMaximum: config.max !== void 0 ? new Date(config.max).toISOString() : void 0, default: config.default });
       schema2 = base(schema2, key, config);
       return schema2;
     } else if (config.type === "object") {
       const nested_properties = {};
       for (const [nested_key, nested_config] of Object.entries(config.properties)) nested_properties[nested_key] = build(nested_key, nested_config);
-      schema2 = Type.Object(nested_properties, { default: config.default, additionalProperties: !(options.validate_options?.stripUnknown ?? false) });
+      schema2 = Typebox.Object(nested_properties, { default: config.default, additionalProperties: !(options.validate_options?.stripUnknown ?? false) });
       schema2 = base(schema2, key, config);
       return schema2;
     } else if (config.type === "array") {
-      schema2 = Type.Array(build(key, config.items), { minItems: config.min, maxItems: config.max, default: config.default });
+      schema2 = Typebox.Array(build(key, config.items), { minItems: config.min, maxItems: config.max, default: config.default });
       schema2 = base(schema2, key, config);
       return schema2;
     } else throw new Error(`Unsupported schema type for ${key}`);
   };
+  const build = (key, config) => {
+    if (!Array.isArray(config)) return buildSingle(key, config);
+    const schemas = config.map((config2) => buildSingle(key, config2));
+    const optional = config.every((config2) => !config2.required);
+    const union_schema = Typebox.Union(schemas);
+    return optional ? Typebox.Optional(union_schema) : union_schema;
+  };
   const properties = {};
   for (const [key, config] of Object.entries(schema)) properties[key] = build(key, config);
-  return Type.Object(properties, { additionalProperties: !(options.validate_options?.stripUnknown ?? false) });
+  return Typebox.Object(properties, { additionalProperties: !(options.validate_options?.stripUnknown ?? false) });
 };
 
 // src/utils/ConvertToYup.util.ts
 import * as Yup from "yup";
 var convertToYup = (schema, options) => {
   const base = (schema2, key, config) => {
+    schema2 = schema2.strict();
     schema2 = schema2.nullable();
     schema2 = schema2.optional();
     if (config.default !== void 0) schema2 = schema2.default(config.default);
@@ -77,7 +85,7 @@ var convertToYup = (schema, options) => {
       );
     return schema2;
   };
-  const build = (key, config) => {
+  const buildSingle = (key, config) => {
     let schema2;
     if (config.type === "string") {
       schema2 = Yup.string().typeError(({ path: path2 }) => (options.error_messages?.string?.type ?? "").replaceAll("{path}", path2));
@@ -121,6 +129,7 @@ var convertToYup = (schema, options) => {
       if (config.min !== void 0) schema2 = schema2.min(config.min, ({ path: path2, min }) => (options.error_messages?.date?.min ?? "").replaceAll("{path}", path2).replaceAll("{min}", new Date(min).toISOString()));
       if (config.max !== void 0) schema2 = schema2.max(config.max, ({ path: path2, max }) => (options.error_messages?.date?.max ?? "").replaceAll("{path}", path2).replaceAll("{max}", new Date(max).toISOString()));
       schema2 = base(schema2, key, config);
+      schema2 = schema2.strict(false);
       return schema2;
     } else if (config.type === "object") {
       schema2 = Yup.object().typeError(({ path: path2 }) => (options.error_messages?.object?.type ?? "").replaceAll("{path}", path2));
@@ -144,7 +153,15 @@ var convertToYup = (schema, options) => {
       schema2 = schema2.of(build(key, config.items));
       schema2 = base(schema2, key, config);
       return schema2;
-    } else throw new Error(`Unsupported schema type for ${key}`);
+    }
+  };
+  const build = (key, config) => {
+    if (!Array.isArray(config)) return buildSingle(key, config);
+    const schemas = config.map((config2) => buildSingle(key, config2));
+    return Yup.lazy((property) => {
+      for (const schema2 of schemas) if (schema2.isValidSync(property)) return schema2;
+      return buildSingle(key, config[0]);
+    });
   };
   const properties = {};
   for (const [key, config] of Object.entries(schema)) properties[key] = build(key, config);
@@ -204,10 +221,28 @@ var YuppiOptionsDefault = {
 };
 
 // src/Yuppi.class.ts
+var cleaned_types_dirs = /* @__PURE__ */ new Set();
 var Yuppi = class {
   options;
   constructor(options = YuppiOptionsDefault) {
     this.options = merge({}, YuppiOptionsDefault, options);
+    void this.cleanupTypesDir();
+  }
+  async cleanupTypesDir() {
+    const types_dir = path.join(this.options.output_dir ?? "./", "types");
+    const exists = async (path2) => {
+      try {
+        await fs.access(path2, fs.constants.F_OK);
+        return true;
+      } catch {
+        return false;
+      }
+    };
+    if (await exists(types_dir) && !cleaned_types_dirs.has(types_dir)) {
+      cleaned_types_dirs.add(types_dir);
+      await fs.rm(types_dir, { recursive: true, force: true });
+      await fs.mkdir(types_dir, { recursive: true });
+    }
   }
   validate(schema, properties) {
     const yup_schema = this.convertToYup(schema);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yuppi",
-  "version": "1.3.22",
+  "version": "1.4.0",
   "description": "Schemas that can be converted to Yup and JSON Schema.",
   "license": "MIT",
   "homepage": "https://github.com/keift/yuppi",