justus 0.5.0 → 0.5.2

package/src/extra/arn.ts

@@ -1,29 +1,47 @@
 import { assertValidation } from '../errors'
 import { AbstractValidator, makeValidatorFactory } from '../types'
 
+/*  ===== TYPES ============================================================= */
+
 /** The type for a validated _string_ ARN (Amazon Resource Name) */
-export type ArnString<Service extends string = string> = string & { __arn: never }
-& ( string extends Service ? string : { [ k in `__arn_${Service}`] : never })
+export type ArnString<
+  Service extends string = string,
+  ResourceType extends string = string,
+> = string & { __arn: never }
+& ( string extends Service ? string : { [ k in `__arn_service_${Service}`] : never })
+& ( string extends ResourceType ? string : { [ k in `__arn_resource_${ResourceType}`] : never })
 
 /** The type for a _parsed_ ARN (Amazon Resource Name) */
-export interface ParsedArn<Service extends string = string> {
+export interface ParsedArn<
+  Service extends string = string,
+  ResourceType extends string = string,
+> {
   /** The full  */
-  Arn: ArnString<Service>,
+  Arn: ArnString<Service, ResourceType>,
   Partition: string,
   Service: Service,
   Region: string,
   Account: string,
-  Resource: [ string, ...string[] ],
+  Resource: [ ResourceType, ...string[] ],
 }
 
-/* ========================================================================== */
+/* ===== INTERNALS ========================================================== */
+
+function assertComponent<T extends string>(
+    actual: string,
+    expected: T | undefined,
+    kind: string,
+): asserts actual is T {
+  if (expected === undefined) return
+  assertValidation(actual === expected, `ARN ${kind} "${actual}" mismatch (expected "${expected}")`)
+}
 
 /** Validate a string and convert it into into an {@link ParsedArn} */
-function parse<Service extends string>(
+function parse<Service extends string, ResourceType extends string>(
     value: unknown,
     service?: Service,
-    type?: string,
-): ParsedArn<Service> {
+    type?: ResourceType,
+): ParsedArn<Service, ResourceType> {
   assertValidation(typeof value == 'string', 'Value is not a "string"')
 
   const segments = value.split(':')
@@ -38,37 +56,34 @@ function parse<Service extends string>(
   assertValidation(!! act, 'Missing account ID in ARN')
   assertValidation(!! res[0], 'Missing resource ID in ARN')
 
-  if (service !== undefined) {
-    assertValidation(svc === service, `ARN Service "${svc}" mismatch (expected "${service}")`)
-  }
-
-  const [ resArray, resString ] = res[0].includes('/') ?
+  const [ [ resType, ...resArray ], resString ] = res[0].includes('/') ?
     [ res[0].split('/'), res[0] ] :
     [ res, res.join(':') ]
 
-  assertValidation(!! resArray[0], 'Invalid resource ID in ARN')
+  assertValidation(!! resType, 'Invalid resource ID in ARN')
 
-  if (type !== undefined) {
-    assertValidation(resArray[0] === type, `ARN Resource Type "${resArray[0]}" mismatch (expected "${type}")`)
-  }
+  assertComponent(svc, service, 'Service')
+  assertComponent(resType, type, 'Resource Type')
 
   const arn = `arn:${prt}:${svc}:${rgn}:${act}:${resString}`
 
   return {
-    Arn: arn as ArnString<Service>,
+    Arn: arn as ArnString<Service, ResourceType>,
     Partition: prt,
-    Service: svc as Service,
+    Service: svc, // as Service,
     Region: rgn || '',
     Account: act,
-    Resource: resArray as [ string, ...string[] ],
+    Resource: [ resType, ...resArray ], // as [ ResourceType, ...string[] ],
   }
 }
 
-/* ========================================================================== */
+/* ===== VALIDATOR CLASSES ================================================== */
 
 /** Validator parsing an ARN (Amazon Resource Name) and returning its components */
-export class ParsedArnValidator<Service extends string = string>
-  extends AbstractValidator<ParsedArn<Service>, string> {
+export class ParsedArnValidator<
+  Service extends string = string,
+  ResourceType extends string = string,
+> extends AbstractValidator<ParsedArn<Service, ResourceType>, string> {
   /**
    * Create a new {@link ParsedArnValidator} instance.
    *
@@ -78,19 +93,21 @@ export class ParsedArnValidator<Service extends string = string>
    *                     representing (e.g. `role` in the `iam` service, or
    *                     `targetgroup` in the `elasticloadbalancing` service)
    */
-  constructor(service?: Service, resourceType?: string)
-  constructor(private _service?: Service, private _type?: string) {
+  constructor(service?: Service, resourceType?: ResourceType)
+  constructor(private _service?: Service, private _type?: ResourceType) {
     super()
   }
 
-  validate(value: unknown): ParsedArn<Service> {
+  validate(value: unknown): ParsedArn<Service, ResourceType> {
     return parse(value, this._service, this._type)
   }
 }
 
 /** Validator validating an ARN (Amazon Resource Name) _string_ */
-export class ArnValidator<Service extends string = string>
-  extends AbstractValidator<ArnString<Service>, string> {
+export class ArnValidator<
+  Service extends string = string,
+  ResourceType extends string = string,
+> extends AbstractValidator<ArnString<Service, ResourceType>, string> {
   /**
    * Create a new {@link ArnValidator} instance.
    *
@@ -100,17 +117,17 @@ export class ArnValidator<Service extends string = string>
    *                     representing (e.g. `role` in the `iam` service, or
    *                     `targetgroup` in the `elasticloadbalancing` service)
    */
-  constructor(service?: Service, resourceType?: string)
-  constructor(private _service?: Service, private _type?: string) {
+  constructor(service?: Service, resourceType?: ResourceType)
+  constructor(private _service?: Service, private _type?: ResourceType) {
     super()
   }
 
-  validate(value: unknown): ArnString<Service> {
+  validate(value: unknown): ArnString<Service, ResourceType> {
     return parse(value, this._service, this._type).Arn
   }
 }
 
-/* ========================================================================== */
+/* ===== VALIDATOR FACTORIES ================================================ */
 
 /**
  * Create a new {@link ParsedArnValidator} parsing an ARN referring to the
@@ -120,10 +137,12 @@ export class ArnValidator<Service extends string = string>
  * component of the ARN's resource (e.g. `role` in the `iam` service, or
  * `targetgroup` in the `elasticloadbalancing` service)
  */
-export function parseArnFactory<Service extends string = string>(
+export function parseArnFactory<
+  Service extends string = string,
+  ResourceType extends string = string>(
     service: Service,
-    resourceType?: string,
-): ParsedArnValidator<Service> {
+    resourceType?: ResourceType,
+): ParsedArnValidator<Service, ResourceType> {
   return new ParsedArnValidator(service, resourceType)
 }
 
@@ -135,14 +154,16 @@ export function parseArnFactory<Service extends string = string>(
  * component of the ARN's resource (e.g. `role` in the `iam` service, or
  * `targetgroup` in the `elasticloadbalancing` service)
  */
-export function arnFactory<Service extends string = string>(
+export function arnFactory<
+  Service extends string = string,
+  ResourceType extends string = string>(
     service: Service,
-    resourceType?: string,
-): ArnValidator<Service> {
+    resourceType?: ResourceType,
+): ArnValidator<Service, ResourceType> {
   return new ArnValidator(service, resourceType)
 }
 
-/* ========================================================================== */
+/* ===== VALIDATOR CONSTANTS ================================================ */
 
 /** Validate a string and parse it into into an {@link ParsedArn} */
 export const parseArn = makeValidatorFactory(new ParsedArnValidator(), parseArnFactory)

package/src/extra/uuid.ts

@@ -4,7 +4,7 @@ export const UUID_EXPR = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a
 
 export type UUIDString = string & { __uuid: never }
 
-export class UUIDValidator extends StringValidator<UUIDString> {
+export class UUIDValidator extends StringValidator<UUIDString, string> {
   constructor() {
     super({ minLength: 36, maxLength: 36, pattern: UUID_EXPR })
   }

package/src/types.ts

@@ -52,7 +52,17 @@ export const defaultValidationOptions: Readonly<Required<ValidationOptions>> = {
 export interface Validator<T = any, I = T> extends Iterable<TupleRestParameter<T, I>> {
   [Symbol.justusValidator]: this
 
-  optional?: boolean
+  /**
+   * A flag indicating whether the type being validated is _optional_ (the input
+   * can be `undefined`) or not (default: `false`).
+   */
+  optional: boolean
+  /**
+   * The _default_ replaced by this `Validator` when the input is `undefined`.
+   *
+   * This is used in conjunction with the `optional` flag.
+   */
+  defaultValue: T | undefined
 
   /** Validate a _value_ and optionally convert it to the required `Type` */
   validate(value: unknown, options?: ValidationOptions | undefined): T
@@ -73,6 +83,7 @@ export function makeValidatorFactory<
 >(validator: V, factory: F): F & V {
   return Object.assign(factory, {
     optional: validator.optional,
+    defaultValue: validator.defaultValue,
     validate: validator.validate.bind(validator),
     [Symbol.iterator]: validator[Symbol.iterator].bind(validator),
     [Symbol.justusValidator]: validator,
@@ -87,7 +98,8 @@ export abstract class AbstractValidator<T, I = T>
 implements Validator<T, I>, Iterable<TupleRestParameter<T, I>> {
   [Symbol.justusValidator] = this
 
-  optional?: boolean = undefined
+  optional: boolean = false
+  defaultValue: T | undefined = undefined
 
   /** Validate a _value_ and optionally convert it to the required `Type` */
   abstract validate(value: unknown, options?: ValidationOptions | undefined): T

package/src/utilities.ts

@@ -1,3 +1,4 @@
+import { assertSchema } from './errors'
 import { registry } from './registry'
 
 import type { Schema, Validation, Validator } from './types'
@@ -6,12 +7,10 @@ import type { Schema, Validation, Validator } from './types'
  * UTILITY FUNCTIONS                                                          *
  * ========================================================================== */
 
-/**
- * Return the `Validator` for the given `Validation`.
- *
- * When `validation` is `undefined` it will return a `Validator<any>`,
- */
+/** Return the `Validator` for the given `Validation` */
 export function getValidator(validation: Validation): Validator {
+  assertSchema(validation !== undefined, 'No validator for undefined validation')
+
   // Null is a constant
   if (validation === null) return new (registry.get('constant'))(null)