justus 0.0.1 → 0.0.2

package/README.md

@@ -27,6 +27,7 @@ typing can be inferred.
   * [Objects](#object-validator) (yes, this is the important one!!!)
   * [Any of, all of](#union-validators)
 * [A (slightly more) complex example](#a-complex-example)
+* [Generating DTS files](#generating-dts-files)
 * [Copyright Notice](NOTICE.md)
 * [License](LICENSE.md)
 
@@ -38,7 +39,7 @@ You can use JUSTUS in your projects quite simply: import, write a schema and
 validate. For example:
 
 ```typescript
-import { validate, object, string, number } from 'justus'
+import { number, object, string, validate } from 'justus'
 
 // Create a validator, validating _objects_ with a specific schema
 const validator = object({
@@ -68,6 +69,8 @@ The `validate` function (or anywhere a _validation_ is needed) can accept a
 _shorthand_ inline syntax. From our example above:
 
 ```typescript
+import { number, string, validate } from 'justus'
+
 const validated = validate({
   foo: string({ minLength: 1 }),
   bar: number,
@@ -103,7 +106,7 @@ const s2 = string({ minLength: 1 }) // validate non empty strings
 Type _branding_ can be used for string primitives. For example:
 
 ```typescript
-import { string } from 'justus'
+import { string, validate } from 'justus'
 
 type UUID = string & { __brand_uuid: never }
 
@@ -118,12 +121,33 @@ const value = validate(uuidValidator, 'C274773D-1444-41E1-9D3A-9F9D584FE8B5')
 value = 'foo' // <- will fail, as "foo" is a `string`, while "value" is a `UUID`
 ```
 
+#### Implicit branding
+
+Sometimes it might be useful to declare the _branding_ of a string without
+recurring to an external type. We can easily do so by adding the `brand`
+property our string constraints. Following the example above:
+
+```typescript
+import { string, validate } from 'justus'
+
+const uuidValidator = string({
+  pattern: /^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$/,
+  minLength: 36,
+  maxLength: 36,
+  brand: 'uuid',
+})
+
+const value = validate(uuidValidator, 'C274773D-1444-41E1-9D3A-9F9D584FE8B5')
+
+value = 'foo' // <- fail! the type of "value" is "string & __brand_uuid: never"
+```
+
 #### Shorthand syntax
 
 The shorthand syntax for string validators is simply `string`. For example:
 
 ```typescript
-import { string } from 'justus'
+import { object, string } from 'justus'
 
 const validator = object({
   foo: string // yep, no parenthesis, just "string"
@@ -157,9 +181,9 @@ const n2 = number({ minimum: 123 }) // validate numbers 123 and greater
 Type _branding_ can be used for number primitives. For example:
 
 ```typescript
-import { number } from 'justus'
+import { number, validate } from 'justus'
 
-type Price = string & { __brand_price: never }
+type Price = number & { __brand_price: never }
 
 const priceValidator = number<Price>({
   multipleOf: 0.01, // cents, anyone? :-)
@@ -171,12 +195,32 @@ const value = validate(priceValidator, 123.45)
 value = 432 // <- will fail, as 432 is a `number`, while "value" is a `Price`
 ```
 
+#### Implicit branding
+
+Sometimes it might be useful to declare the _branding_ of a number without
+recurring to an external type. We can easily do so by adding the `brand`
+property our number constraints. Following the example above:
+
+```typescript
+import { number, validate } from 'justus'
+
+const priceValidator = number({
+  multipleOf: 0.01, // cents, anyone? :-)
+  minimum: 0, // no negative prices, those are _discounts_
+  brand: 'price',
+})
+
+const value = validate(priceValidator, 123.45)
+
+value = 432 // <- fail! the type of "value" is "number & __brand_price: never"
+```
+
 #### Shorthand syntax
 
 The shorthand syntax for number validators is simply `number`. For example:
 
 ```typescript
-import { number } from 'justus'
+import { number, object } from 'justus'
 
 const validator = object({
   foo: number // yep, no parenthesis, just "number"
@@ -265,7 +309,7 @@ Array validators are created using the `array` or `arrayOf` functions:
 import { array, arrayOf, number, string } from 'justus'
 
 const a1 = array() // validates any array
-const a2 = string({ maxItems: 10, items: string }) // array of strings
+const a2 = array({ maxItems: 10, items: string }) // array of strings
 const a3 = arrayOf(number) // array of numbers
 ```
 
@@ -281,7 +325,7 @@ const a3 = arrayOf(number) // array of numbers
 The shorthand syntax for string validators is simply `array`. For example:
 
 ```typescript
-import { array } from 'justus'
+import { array, object } from 'justus'
 
 const validator = object({
   foo: array // validate any array, of any length, containing anything
@@ -293,7 +337,7 @@ The `arrayOf` function can also be considered a _shorthand_ of the full
 equivalent:
 
 ```typescript
-import { array, arrayOf } from 'justus'
+import { array, arrayOf, string } from 'justus'
 
 const a1 = array({ items: string })
 const a2 = arrayOf(string) // same as above, just more readable
@@ -328,7 +372,7 @@ const d2 = date({ format: 'iso' }) // validate ISO dates
 The shorthand syntax for number validators is simply `date`. For example:
 
 ```typescript
-import { date } from 'justus'
+import { date, object } from 'justus'
 
 const validator = object({
   foo: date // anything that can be converted to `Date` will be!
@@ -357,10 +401,10 @@ const t2 = tuple([ string, ...number, boolean ]) // yay! rest parameters!
 As shown above, any `Validator` (or one of its shorthands) can be used as a
 _rest parameter_ implying zero or more elements of the specified kind.
 
-A more complext example:
+A more complex example:
 
 ```typescript
-import { tuple, string, number, object } from 'justus'
+import { number, object, string, tuple, validate } from 'justus'
 
 const myObject = object({
   version: number,
@@ -371,7 +415,7 @@ const myObject = object({
 const sillyTuple = tuple([ 'start', ...myObject, 'end' ] as const)
 
 // Validate using our tuple:
-validate(tuple, [
+validate(sillyTuple, [
   'start', // yep, a constant
   { version: 1, title: 'Hello world' },
   { version: 2, title: 'Foo, bar and baz' },
@@ -414,7 +458,7 @@ Sometimes it's necessary to allow additional properties in an object.
 Destructuring `...allowAdditionalProperties` in an objects does the trick!
 
 ```typescript
-import { object, string, number, boolean } from 'justus'
+import { allowAdditionalProperties, boolean, number, object, string, validate } from 'justus'
 
 const o1 = object({
   foo: string, // any string
@@ -422,7 +466,7 @@ const o1 = object({
   ...allowAdditionalProperties, // any other key will be "any"
 })
 
-const result1 = validate(o1, ... some object ...)
+const result1 = validate(o1, something)
 
 result1.foo // <-- this will be a "string"
 result1.bar // <-- this will be a "number"
@@ -436,12 +480,11 @@ const o2 = object({
   ...allowAdditionalProperties(boolean), // any other key will be "boolean"
 })
 
-const result2 = validate(o2, ... some object ...)
+const result2 = validate(o2, something)
 
 result2.foo // <-- this will be a "string"
 result2.bar // <-- this will be a "number"
 result2.baz // <-- additional property, this will be "boolean"
-
 ```
 
 Here `allowAdditionalProperties` is also a function, which can take some
@@ -485,7 +528,7 @@ To do so, simply override in the extended object as follows:
 Simply destructure one into another. For example:
 
 ```typescript
-import { object, string, number, boolean } from 'justus'
+import { allowAdditionalProperties, boolean, number, object, string } from 'justus'
 
 const o1 = object({
   foo: string, // any string
@@ -496,7 +539,33 @@ const o1 = object({
 const o2 = object({
   ...o1, // anything part of "o1" will be here as well!
   baz: boolean, // add "baz" to "o1", forcing it to be a "boolean"
-  ...allowAdditionaProperties(false), // no more additional properties here!
+  ...allowAdditionalProperties(false), // no more additional properties here!
+} as const)
+```
+
+#### Ensure properties never exist
+
+When allowing extra properties, or extending objects, we might want to validate
+the _non-existance_ of a specific property. We can do this setting a property
+to `never`:
+
+```typescript
+import { allowAdditionalProperties, never, number, object, string } from 'justus'
+
+const o1 = object({
+  foo: string, // any string
+  bar: number, // any number
+})
+
+const o2 = object({
+  ...o1, // anything part of "o1" will be here as well!
+  bar: never, // remove "bar" from the properties inherited by "o1"
+} as const)
+
+const o3 = object({
+  ...o1, // anything part of "o1" will be here as well!
+  ...allowAdditionalProperties, // allow additional properties as "any"
+  baz: never, // even with additional properties, "baz" must not exist
 } as const)
 ```
 
@@ -525,28 +594,28 @@ functions.
 To make sure all validations pass use `allOf`:
 
 ```typescript
-import { allOf, object, string, number } from 'justus'
+import { allOf, number, object, string, validate } from 'justus'
 
 const o1 = object({ foo: string })
 const o2 = object({ bar: number })
 
-const result = validate(allOf(o1, o2), ... some object ...)
+const result = validate(allOf(o1, o2), something)
 // result here will have the type of what's inferred by o1 _and_ o2
 
 result.foo // <-- this is a "string"
 result.bar // <-- this is a "number"
 
 // be careful about never!
-const result2 = validate(allOf(number, string), ... some primitive ...)
+const result2 = validate(allOf(number, string), something)
 // obviously "result2" will be of type "never" as "number" and "string" do not match!
 ```
 
 More useful, to make sure all validations pass use `oneOf`:
 
 ```typescript
-import { oneOf, string, number } from 'justus'
+import { number, oneOf, string, validate } from 'justus'
 
-const result = validate(oneOf(number, string), ... some primitive ...)
+const result = validate(oneOf(number, string), something)
 
 result // <-- its type will be "number | string"
 ```
@@ -562,16 +631,7 @@ Let's assume we have some _time series_ data, but we can expect this in a
 couple of different flavors, either V1 or V2 with some subtle differences:
 
 ```typescript
-import {
-  arrayOf,
-  date,
-  number,
-  object,
-  oneOf,
-  string,
-  tuple,
-  validate,
-} from '../src'
+import { arrayOf, date, number, object, oneOf, string, tuple, validate } from 'justus'
 
 // Our V1 time-series tuple is simply a timestamp followed by a numeric value
 const entryv1 = tuple([ date, number ] as const)
@@ -618,3 +678,62 @@ if (result.version === 1) {
   result.average // this will be a "number""
 }
 ```
+
+
+Generating DTS files
+--------------------
+
+Sometimes it might be necessary to generate `.d.ts` files for your schemas,
+rather than relying on the type inference provided by JUSTUS.
+
+For example, if you were to use JUSTUS on a server application to validate
+HTTP requests and responses, and wanted to have strong typing when interacting
+with it from a client, you might not necessarily want to have JUSTUS (and your
+schemas) as a client dependency.
+
+So, assuming your schemas might look something like this:
+
+```typescript
+import { number, object, string } from 'justus'
+
+// this will be exported as a type
+const uuid = string({ brand: 'uuid ' })
+
+// this will be embedded in product below
+const price = number({ brand: 'price' })
+
+// object mapping two validators above
+const product = object({
+  uuid,
+  price,
+  name: string({ minLength: 1 }),
+ })
+```
+
+We can generate the DTS for `UUID` and `Product` (we specifically not export
+`Product` in this example) using our `dts-generator` as follows:
+
+```typescript
+import { generateTypes } from 'justus/dts-generator'
+
+// Note how we rename the exports to "UUID" and "Product" (casing, ...)
+const dts = generateTypes({
+  UUID: uuid,
+  Product: product,
+})
+```
+
+The resulting `dts` will be a `string` containing the DTS as follows:
+
+```typescript
+export type UUID = string & {
+    __brand_uuid : never;
+};
+export type Product = {
+    uuid: UUID;
+    price: number & {
+        __brand_price: never;
+    };
+    name: string;
+};
+```

package/dist/dts-generator.js

@@ -0,0 +1,166 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+
+// src/dts-generator.ts
+__export(exports, {
+  generateTypes: () => generateTypes,
+  registerTypeGenerator: () => registerTypeGenerator
+});
+var import_typescript = __toModule(require("typescript"));
+var import_index = __toModule(require("./index.js"));
+var generators = /* @__PURE__ */ new Map();
+function registerTypeGenerator(validator, generator) {
+  (0, import_index.assertSchema)(validator.prototype instanceof import_index.Validator, "Not a `Validator` class");
+  generators.set(validator, generator);
+}
+function generateTypes(validations) {
+  const validators = /* @__PURE__ */ new Map();
+  const references = /* @__PURE__ */ new Map();
+  Object.entries(validations).forEach(([name, validation]) => {
+    const validator = (0, import_index.getValidator)(validation);
+    if (!references.has(validator))
+      references.set(validator, name);
+    validators.set(name, validator);
+  });
+  const types = [];
+  for (const [name, validator] of validators.entries()) {
+    const referenceable = new Map(references);
+    if (referenceable.get(validator) === name) {
+      referenceable.delete(validator);
+    }
+    const type = generateTypeNode(validator, referenceable);
+    const modifiers = [import_typescript.default.factory.createModifier(import_typescript.default.SyntaxKind.ExportKeyword)];
+    const decl = import_typescript.default.factory.createTypeAliasDeclaration(void 0, modifiers, name, [], type);
+    types.push(decl);
+  }
+  return import_typescript.default.createPrinter().printList(import_typescript.default.ListFormat.SourceFileStatements, import_typescript.default.factory.createNodeArray(types), import_typescript.default.createSourceFile("types.d.ts", "", import_typescript.default.ScriptTarget.Latest));
+}
+function generateTypeNode(validator, references) {
+  const reference = references.get(validator);
+  if (reference)
+    return import_typescript.default.factory.createTypeReferenceNode(reference);
+  const generator = generators.get(validator.constructor);
+  (0, import_index.assertSchema)(!!generator, `Type generator for "${validator.constructor.name}" not found`);
+  return generator(validator, references);
+}
+var anyType = import_typescript.default.factory.createKeywordTypeNode(import_typescript.default.SyntaxKind.AnyKeyword);
+var anyArrayType = import_typescript.default.factory.createArrayTypeNode(anyType);
+var booleanType = import_typescript.default.factory.createKeywordTypeNode(import_typescript.default.SyntaxKind.BooleanKeyword);
+var numberType = import_typescript.default.factory.createKeywordTypeNode(import_typescript.default.SyntaxKind.NumberKeyword);
+var neverType = import_typescript.default.factory.createKeywordTypeNode(import_typescript.default.SyntaxKind.NeverKeyword);
+var stringType = import_typescript.default.factory.createKeywordTypeNode(import_typescript.default.SyntaxKind.StringKeyword);
+var recordType = import_typescript.default.factory.createMappedTypeNode(void 0, import_typescript.default.factory.createTypeParameterDeclaration("key", stringType), void 0, void 0, anyType, void 0);
+var readonlyKeyword = [import_typescript.default.factory.createModifier(import_typescript.default.SyntaxKind.ReadonlyKeyword)];
+var optionalKeyword = import_typescript.default.factory.createToken(import_typescript.default.SyntaxKind.QuestionToken);
+registerTypeGenerator(import_index.AnyValidator, () => anyType);
+registerTypeGenerator(import_index.AnyArrayValidator, () => anyArrayType);
+registerTypeGenerator(import_index.AnyNumberValidator, () => numberType);
+registerTypeGenerator(import_index.AnyObjectValidator, () => recordType);
+registerTypeGenerator(import_index.AnyStringValidator, () => stringType);
+registerTypeGenerator(import_index.BooleanValidator, () => booleanType);
+registerTypeGenerator(import_index.DateValidator, () => import_typescript.default.factory.createTypeReferenceNode("Date"));
+registerTypeGenerator(import_index.ArrayValidator, (validator, references) => {
+  const itemType = generateTypeNode(validator.items, references);
+  return import_typescript.default.factory.createArrayTypeNode(itemType);
+});
+registerTypeGenerator(import_index.ConstantValidator, (validator) => {
+  const literal = typeof validator.constant === "number" ? import_typescript.default.factory.createNumericLiteral(validator.constant) : typeof validator.constant === "string" ? import_typescript.default.factory.createStringLiteral(validator.constant) : validator.constant === false ? import_typescript.default.factory.createFalse() : validator.constant === true ? import_typescript.default.factory.createTrue() : validator.constant === null ? import_typescript.default.factory.createNull() : void 0;
+  (0, import_index.assertSchema)(!!literal, `Invalid constant "${validator.constant}"`);
+  return import_typescript.default.factory.createLiteralTypeNode(literal);
+});
+registerTypeGenerator(import_index.NumberValidator, (validator) => {
+  if (!validator.brand)
+    return numberType;
+  const signature = import_typescript.default.factory.createPropertySignature(void 0, `__brand_${validator.brand}`, void 0, neverType);
+  const literal = import_typescript.default.factory.createTypeLiteralNode([signature]);
+  return import_typescript.default.factory.createIntersectionTypeNode([numberType, literal]);
+});
+registerTypeGenerator(import_index.StringValidator, (validator) => {
+  if (!validator.brand)
+    return stringType;
+  const signature = import_typescript.default.factory.createPropertySignature(void 0, `__brand_${validator.brand}`, void 0, neverType);
+  const literal = import_typescript.default.factory.createTypeLiteralNode([signature]);
+  return import_typescript.default.factory.createIntersectionTypeNode([stringType, literal]);
+});
+registerTypeGenerator(import_index.TupleValidator, (validator, references) => {
+  const members = validator.members;
+  const { count, first, next } = members.reduce(({ count: count2, first: first2, next: next2 }, { single }, i) => {
+    if (!single) {
+      if (i < first2)
+        first2 = i;
+      next2 = i + 1;
+      count2 += 1;
+    }
+    return { count: count2, first: first2, next: next2 };
+  }, { count: 0, first: members.length, next: -1 });
+  if (count < 2) {
+    const types2 = members.map(({ single, validator: validator2 }) => {
+      const memberType = generateTypeNode(validator2, references);
+      if (single)
+        return generateTypeNode(validator2, references);
+      const arrayType = import_typescript.default.factory.createArrayTypeNode(memberType);
+      return import_typescript.default.factory.createRestTypeNode(arrayType);
+    });
+    return import_typescript.default.factory.createTupleTypeNode(types2);
+  }
+  const before = members.slice(0, first).map(({ validator: validator2 }) => generateTypeNode(validator2, references));
+  const types = members.slice(first, next).map(({ validator: validator2 }) => generateTypeNode(validator2, references));
+  const after = members.slice(next).map(({ validator: validator2 }) => generateTypeNode(validator2, references));
+  const union = import_typescript.default.factory.createUnionTypeNode(types);
+  const array = import_typescript.default.factory.createArrayTypeNode(union);
+  const rest = import_typescript.default.factory.createRestTypeNode(array);
+  return import_typescript.default.factory.createTupleTypeNode([...before, rest, ...after]);
+});
+registerTypeGenerator(import_index.AllOfValidator, (validator, references) => {
+  const members = validator.validators.map((validator2) => generateTypeNode(validator2, references));
+  return import_typescript.default.factory.createIntersectionTypeNode(members);
+});
+registerTypeGenerator(import_index.OneOfValidator, (validator, references) => {
+  const members = validator.validators.map((validator2) => generateTypeNode(validator2, references));
+  return import_typescript.default.factory.createUnionTypeNode(members);
+});
+registerTypeGenerator(import_index.ObjectValidator, (validator, references) => {
+  const properties = [];
+  for (const [key, property] of validator.properties.entries()) {
+    const { validator: validator2, readonly, optional } = property || { optional: true };
+    const type = validator2 ? generateTypeNode(validator2, references) : neverType;
+    const signature = import_typescript.default.factory.createPropertySignature(readonly ? readonlyKeyword : void 0, key, optional ? optionalKeyword : void 0, type);
+    properties.push(signature);
+  }
+  if (validator.additionalProperties) {
+    const extra = import_typescript.default.factory.createMappedTypeNode(void 0, import_typescript.default.factory.createTypeParameterDeclaration("key", stringType), void 0, void 0, generateTypeNode(validator.additionalProperties, references), void 0);
+    if (properties.length == 0)
+      return extra;
+    const type = import_typescript.default.factory.createTypeLiteralNode(properties);
+    return import_typescript.default.factory.createIntersectionTypeNode([type, extra]);
+  } else {
+    return import_typescript.default.factory.createTypeLiteralNode(properties);
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generateTypes,
+  registerTypeGenerator
+});
+//# sourceMappingURL=dts-generator.js.map

package/dist/dts-generator.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../src/dts-generator.ts"],
+  "mappings": "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",
+  "names": []
+}