@naturalcycles/nodejs-lib 15.89.1 → 15.90.1

package/dist/validation/joi/string.extensions.js

@@ -1,104 +0,0 @@
-import { localTime } from '@naturalcycles/js-lib/datetime/localTime.js';
-export function stringExtensions(joi) {
-    return {
-        type: 'string',
-        base: joi.string(),
-        messages: {
-            'string.dateString': '"{{#label}}" must be an ISO8601 date (yyyy-mm-dd)',
-            'string.dateStringMin': '"{{#label}}" must be not earlier than {{#min}}',
-            'string.dateStringMax': '"{{#label}}" must be not later than {{#max}}',
-            'string.dateStringCalendarAccuracy': '"{{#label}}" must be a VALID calendar date',
-            'string.stripHTML': '"{{#label}}" must NOT contain any HTML tags',
-        },
-        rules: {
-            dateString: {
-                method(min, max) {
-                    return this.$_addRule({
-                        name: 'dateString',
-                        args: { min, max },
-                    });
-                },
-                args: [
-                    {
-                        name: 'min',
-                        // ref: true, // check false
-                        assert: v => v === undefined || typeof v === 'string',
-                        message: 'must be a string',
-                    },
-                    {
-                        name: 'max',
-                        // ref: true,
-                        assert: v => v === undefined || typeof v === 'string',
-                        message: 'must be a string',
-                    },
-                ],
-                validate(v, helpers, args) {
-                    // console.log('dateString validate called', {v, args})
-                    let err;
-                    let { min, max } = args;
-                    // Today allows +-14 hours gap to account for different timezones
-                    if (max === 'today') {
-                        max = getTodayStrPlus15();
-                    }
-                    if (min === 'today') {
-                        min = getTodayStrMinus15();
-                    }
-                    // console.log('min/max', min, max)
-                    const parts = /^(\d{4})-(\d{2})-(\d{2})$/.exec(v);
-                    if (!parts || parts.length < 4) {
-                        err = 'string.dateString';
-                    }
-                    else if (min && v < min) {
-                        err = 'string.dateStringMin';
-                    }
-                    else if (max && v > max) {
-                        err = 'string.dateStringMax';
-                    }
-                    else if (!isValidDate(parts)) {
-                        err = 'string.dateStringCalendarAccuracy';
-                    }
-                    if (err) {
-                        return helpers.error(err, args);
-                    }
-                    return v; // validation passed
-                },
-            },
-        },
-    };
-}
-const DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-// Based on: https://github.com/ajv-validator
-function isValidDate(parts) {
-    const year = Number(parts[1]);
-    const month = Number(parts[2]);
-    const day = Number(parts[3]);
-    return (month >= 1 &&
-        month <= 12 &&
-        day >= 1 &&
-        day <= (month === 2 && isLeapYear(year) ? 29 : DAYS[month]));
-}
-function isLeapYear(year) {
-    return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
-}
-let lastCheckedPlus = 0;
-let todayStrPlusCached;
-let lastCheckedMinus = 0;
-let todayStrMinusCached;
-function getTodayStrPlus15() {
-    const now = Date.now();
-    if (now - lastCheckedPlus < 3_600_000) {
-        // cached for 1 hour
-        return todayStrPlusCached;
-    }
-    lastCheckedPlus = now;
-    return (todayStrPlusCached = localTime.now().plus(15, 'hour').toISODate());
-}
-function getTodayStrMinus15() {
-    const now = Date.now();
-    if (now - lastCheckedMinus < 3_600_000) {
-        // cached for 1 hour
-        return todayStrMinusCached;
-    }
-    lastCheckedMinus = now;
-    return (todayStrMinusCached = localTime.now().plus(-15, 'hour').toISODate());
-}

package/src/validation/joi/index.ts

@@ -1,32 +0,0 @@
-import type {
-  AlternativesSchema,
-  AnySchema,
-  ArraySchema,
-  BinarySchema,
-  BooleanSchema,
-  DateSchema,
-  FunctionSchema,
-  ObjectSchema,
-  ValidationErrorItem,
-} from 'joi'
-
-export * from './joi.extensions.js'
-export * from './joi.model.js'
-export * from './joi.shared.schemas.js'
-export * from './joi.validation.error.js'
-export * from './joi.validation.util.js'
-
-export type {
-  AlternativesSchema,
-  AnySchema,
-  ArraySchema,
-  BinarySchema,
-  BooleanSchema,
-  DateSchema,
-  FunctionSchema,
-  ObjectSchema,
-  ValidationErrorItem,
-}
-// extended
-export type { NumberSchema } from './number.extensions.js'
-export type { StringSchema } from './string.extensions.js'

package/src/validation/joi/joi.extensions.ts

@@ -1,38 +0,0 @@
-import JoiLib from 'joi'
-import type { NumberSchema } from './number.extensions.js'
-import { numberExtensions } from './number.extensions.js'
-import type { StringSchema } from './string.extensions.js'
-import { stringExtensions } from './string.extensions.js'
-
-export interface ExtendedJoi extends JoiLib.Root {
-  // eslint-disable-next-line id-denylist
-  string: <TSchema = string>() => StringSchema<TSchema>
-  // eslint-disable-next-line id-denylist
-  number: <TSchema = number>() => NumberSchema<TSchema>
-}
-
-/**
- * This is the only right place to import Joi from
- */
-// eslint-disable-next-line @typescript-eslint/naming-convention
-export const Joi: ExtendedJoi = JoiLib.defaults(schema => {
-  // hack to prevent infinite recursion due to .empty('') where '' is a stringSchema itself
-  if (schema.type === 'string') {
-    return (
-      (schema as StringSchema)
-        .trim() // trim all strings by default
-        // 2020-09-21: null values are NOT treated as EMPTY enymore
-        // .empty([schema.valid('', null)]) // treat '' or null as empty (undefined, will be stripped out)
-        // treat '' as empty (undefined, will be stripped out)
-        .empty([schema.valid('')])
-    )
-  }
-
-  // Treat `null` as undefined for all schema types
-  // undefined values will be stripped by default from object values
-  // 2020-09-21: breaking change: null values are NOT treated as EMPTY anymore
-  // return schema.empty(null)
-  return schema
-})
-  .extend((joi: typeof JoiLib) => stringExtensions(joi))
-  .extend((joi: typeof JoiLib) => numberExtensions(joi))

package/src/validation/joi/joi.model.ts

@@ -1,12 +0,0 @@
-// export interface ObjectSchema<T = any> extends JoiObjectSchema<T> {
-//   // Open-ended index signature to allow for easier .concat(baseDBEntitySchema)
-//   [k: string]: any
-// }
-
-/**
- * This type is useful to allow "joi schema merging".
- * Because by default Joi doesn't allow normal merging.
- * E.g `joiSchema.concat` doesn't play well when some property exists
- * in both left and right side.
- */
-export type JoiSchemaObject<T> = Partial<Record<keyof T, any>>

package/src/validation/joi/joi.shared.schemas.ts

@@ -1,207 +0,0 @@
-import {
-  _numberEnumKeys,
-  _numberEnumValues,
-  _stringEnumKeys,
-  _stringEnumValues,
-} from '@naturalcycles/js-lib'
-import {
-  type AnyObject,
-  type BaseDBEntity,
-  type IANATimezone,
-  type IsoDate,
-  type IsoDateTime,
-  JWT_REGEX,
-  type NumberEnum,
-  type StringEnum,
-  type StringMap,
-  type UnixTimestamp,
-  type UnixTimestampMillis,
-} from '@naturalcycles/js-lib/types'
-import type { AlternativesSchema, AnySchema, ArraySchema, ObjectSchema } from 'joi'
-import {
-  BASE62_REGEX,
-  BASE64_REGEX,
-  BASE64URL_REGEX,
-  ID_REGEX,
-  MAC_ADDRESS_REGEX,
-  SEMVER_REGEX,
-  SLUG_REGEX,
-} from '../regexes.js'
-import { Joi } from './joi.extensions.js'
-import type { NumberSchema } from './number.extensions.js'
-import type { StringSchema } from './string.extensions.js'
-
-export const booleanSchema = Joi.boolean()
-export const booleanDefaultToFalseSchema = Joi.boolean().default(false)
-export const stringSchema = Joi.string()
-export const stringSchemaTyped = <T>(): StringSchema<T> => Joi.string<T>()
-export const numberSchema = Joi.number()
-export const numberSchemaTyped = <T>(): NumberSchema<T> => Joi.number<T>()
-export const integerSchema = Joi.number().integer()
-export const percentageSchema = Joi.number().integer().min(0).max(100)
-export const dateStringSchema: StringSchema<IsoDate> = stringSchema.dateString()
-export const binarySchema = Joi.binary()
-export const dateObjectSchema = Joi.object().instance(Date)
-
-const DATE_INTERVAL_REGEX = /^\d{4}-\d{2}-\d{2}\/\d{4}-\d{2}-\d{2}$/
-export const dateIntervalStringSchema = stringSchema.regex(DATE_INTERVAL_REGEX).messages({
-  'string.pattern.base': `must be a DateInterval string`,
-})
-
-export const DATE_TIME_STRING_REGEX =
-  /^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?(?:Z|[+-]\d{2}:\d{2})?)?$/
-
-export const dateTimeStringSchema = stringSchema.regex(DATE_TIME_STRING_REGEX).messages({
-  'string.pattern.base': `must be a DateTime string`,
-}) as StringSchema<IsoDateTime>
-
-/**
- * Allows all values of a String Enum.
- */
-export const stringEnumValueSchema = <ENUM extends StringEnum>(
-  en: ENUM,
-): StringSchema<ENUM[keyof ENUM]> => Joi.string<ENUM[keyof ENUM]>().valid(..._stringEnumValues(en))
-
-/**
- * Allows all keys of a String Enum.
- */
-export const stringEnumKeySchema = <ENUM extends StringEnum>(en: ENUM): StringSchema =>
-  Joi.string().valid(..._stringEnumKeys(en))
-
-/**
- * Allows all values of a String Enum.
- */
-export const numberEnumValueSchema = <ENUM extends NumberEnum>(
-  en: ENUM,
-): NumberSchema<ENUM[keyof ENUM]> => Joi.number<ENUM[keyof ENUM]>().valid(..._numberEnumValues(en))
-
-/**
- * Allows all keys of a Number Enum.
- */
-export const numberEnumKeySchema = <ENUM extends NumberEnum>(en: ENUM): StringSchema =>
-  Joi.string().valid(..._numberEnumKeys(en))
-
-export const urlSchema = (scheme: string | string[] = 'https'): StringSchema =>
-  Joi.string().uri({ scheme })
-
-export function arraySchema<T>(items: AnySchema<T>): ArraySchema<T[]> {
-  return Joi.array().items(items)
-}
-
-export function anyObjectSchema<T extends AnyObject>(): ObjectSchema<T> {
-  return Joi.object().options({ stripUnknown: false })
-}
-
-export function objectSchema<T extends AnyObject>(schema: {
-  [key in keyof Partial<T>]: AnySchema<T[key]>
-}): ObjectSchema<T> {
-  return Joi.object(schema)
-}
-
-export function stringMapSchema<T>(
-  key: AnySchema,
-  value: AnySchema<T>,
-): ObjectSchema<StringMap<T>> {
-  return Joi.object().pattern(key, value)
-}
-
-export function oneOfSchema<T = any>(...schemas: AnySchema[]): AlternativesSchema<T> {
-  return Joi.alternatives(schemas)
-}
-
-export const anySchema = Joi.any()
-export const base62Schema = stringSchema.regex(BASE62_REGEX)
-export const base64Schema = stringSchema.regex(BASE64_REGEX)
-export const base64UrlSchema = stringSchema.regex(BASE64URL_REGEX)
-
-export const jwtSchema = stringSchema.regex(JWT_REGEX)
-
-// 1g498efj5sder3324zer
-/**
- * [a-zA-Z0-9_]*
- * 6-64 length
- */
-export const idSchema = stringSchema.regex(ID_REGEX)
-
-export const idBase62Schema = base62Schema.min(8).max(64)
-export const idBase64Schema = base64Schema.min(8).max(64)
-export const idBase64UrlSchema = base64UrlSchema.min(8).max(64)
-
-/**
- * "Slug" - a valid URL, filename, etc.
- */
-export const slugSchema = stringSchema.regex(SLUG_REGEX).min(1).max(255)
-
-const TS_2500 = 16725225600 // 2500-01-01
-const TS_2000 = 946684800 // 2000-01-01
-
-/**
- * Between years 1970 and 2050
- */
-export const unixTimestampSchema = numberSchema
-  .integer()
-  .min(0)
-  .max(TS_2500) as NumberSchema<UnixTimestamp>
-/**
- * Between years 2000 and 2050
- */
-export const unixTimestamp2000Schema = numberSchema
-  .integer()
-  .min(TS_2000)
-  .max(TS_2500) as NumberSchema<UnixTimestamp>
-/**
- * Between years 1970 and 2050
- */
-export const unixTimestampMillisSchema = numberSchema
-  .integer()
-  .min(0)
-  .max(TS_2500 * 1000) as NumberSchema<UnixTimestampMillis>
-/**
- * Between years 2000 and 2050
- */
-export const unixTimestampMillis2000Schema = numberSchema
-  .integer()
-  .min(TS_2000 * 1000)
-  .max(TS_2500 * 1000) as NumberSchema<UnixTimestampMillis>
-
-// 2
-export const verSchema = numberSchema.optional().integer().min(1).max(100)
-
-/**
- * Be careful, by default emailSchema does TLD validation. To disable it - use `stringSchema.email({tld: false}).lowercase()`
- */
-export const emailSchema = stringSchema.email().lowercase()
-
-/**
- * Pattern is simplified for our use, it's not a canonical SemVer.
- */
-export const semVerSchema = stringSchema.regex(SEMVER_REGEX)
-// todo: .error(() => 'should be SemVer')
-
-export const userAgentSchema = stringSchema
-  .min(5) // I've seen UA of `Android` (7 characters)
-  .max(400)
-
-export const utcOffsetSchema = numberSchema
-  .min(-14 * 60)
-  .max(14 * 60)
-  .dividable(15)
-
-export const ianaTimezoneSchema = stringSchema
-  // UTC is added to assist unit-testing, which uses UTC by default (not technically a valid Iana timezone identifier)
-  .valid(...Intl.supportedValuesOf('timeZone'), 'UTC')
-  .messages({
-    'any.only': `must be a valid IANA timezone string`,
-  }) as StringSchema<IANATimezone>
-
-export const ipAddressSchema = stringSchema.ip()
-
-export const baseDBEntitySchema: ObjectSchema<BaseDBEntity> = objectSchema<BaseDBEntity>({
-  id: stringSchema.optional(),
-  created: unixTimestamp2000Schema.optional(),
-  updated: unixTimestamp2000Schema.optional(),
-})
-
-export const macAddressSchema = stringSchema.regex(MAC_ADDRESS_REGEX)
-
-export const uuidSchema = stringSchema.uuid()

package/src/validation/joi/joi.validation.error.ts

@@ -1,35 +0,0 @@
-import type { ErrorData } from '@naturalcycles/js-lib/error'
-import { AppError } from '@naturalcycles/js-lib/error/error.util.js'
-import type { ValidationErrorItem } from 'joi'
-
-/**
- * Example of ValidationErrorItem:
- *
- * {
- *   message: '"temperature" must be larger than or equal to 33',
- *   path: [ 'entries', 10, 'temperature' ],
- *   type: 'number.min',
- *   context: { limit: 33, value: 30, key: 'temperature', label: 'temperature' }
- * }
- */
-export interface JoiValidationErrorData extends ErrorData {
-  joiValidationErrorItems: ValidationErrorItem[]
-  joiValidationInputName?: string
-  joiValidationInputId?: string
-  /**
-   * Error "annotation" is stripped in Error.message.
-   * This field contains the "full" annotation.
-   *
-   * This field is non-enumerable, won't be printed or included in JSON by default,
-   * but still accessible programmatically (via `err.data.annotation`) when needed!
-   */
-  annotation?: string
-}
-
-export class JoiValidationError extends AppError<JoiValidationErrorData> {
-  constructor(message: string, data: JoiValidationErrorData) {
-    super(message, data, {
-      name: 'JoiValidationError',
-    })
-  }
-}

package/src/validation/joi/joi.validation.util.ts

@@ -1,183 +0,0 @@
-/*
- * Does 2 things:
- * 1. Validates the value according to Schema passed.
- * 2. Converts the value (also according to Schema).
- *
- * "Converts" mean e.g trims all strings from leading/trailing spaces.
- */
-
-import {
-  _hb,
-  _isObject,
-  type ValidationFunction,
-  type ValidationFunctionResult,
-} from '@naturalcycles/js-lib'
-import { _assert } from '@naturalcycles/js-lib/error/assert.js'
-import { _truncateMiddle } from '@naturalcycles/js-lib/string/string.util.js'
-import type { AnySchema, ValidationError, ValidationOptions } from 'joi'
-import type { JoiValidationErrorData } from './joi.validation.error.js'
-import { JoiValidationError } from './joi.validation.error.js'
-
-// Strip colors in production (for e.g Sentry reporting)
-// const stripColors = process.env.NODE_ENV === 'production' || !!process.env.GAE_INSTANCE
-// Currently colors do more bad than good, so let's strip them always for now
-const stripColors = true
-
-const defaultOptions: ValidationOptions = {
-  abortEarly: false,
-  convert: true,
-  allowUnknown: true,
-  stripUnknown: {
-    objects: true,
-    // true: it will SILENTLY strip invalid values from arrays. Very dangerous! Can lead to data loss!
-    // false: it will THROW validation error if any of array items is invalid
-    // Q: is it invalid if it has unknown properties?
-    // A: no, unknown properties are just stripped (in both 'false' and 'true' states), array is still valid
-    // Q: will it strip or keep unknown properties in array items?..
-    // A: strip
-    arrays: false, // let's be very careful with that! https://github.com/hapijs/joi/issues/658
-  },
-  presence: 'required',
-  // errors: {
-  //   stack: true,
-  // }
-}
-
-export function getJoiValidationFunction<T>(
-  schema: AnySchema<T>,
-): ValidationFunction<T, T, JoiValidationError> {
-  return (input, opt) => {
-    _assert(!opt?.mutateInput, 'mutateInput=true is not yet supported with Joi')
-    return getValidationResult(input, schema, opt?.inputName)
-  }
-}
-
-/**
- * Validates with Joi.
- * Throws JoiValidationError if invalid.
- * Returns *converted* value.
- *
- * If `schema` is undefined - returns value as is.
- */
-export function validate<T>(
-  input: any,
-  schema?: AnySchema<T>,
-  inputName?: string,
-  opt: ValidationOptions = {},
-): T {
-  const [error, returnValue] = getValidationResult(input, schema, inputName, opt)
-  if (error) throw error
-  return returnValue
-}
-
-/**
- * Validates with Joi.
- * Returns JoiValidationResult with converted value and error (if any).
- * Does not throw.
- *
- * Joi does NOT mutate the input.
- *
- * If `schema` is undefined - returns value as is.
- */
-export function getValidationResult<T>(
-  input: T,
-  schema?: AnySchema<T>,
-  inputName?: string,
-  options: ValidationOptions = {},
-): ValidationFunctionResult<T, JoiValidationError> {
-  if (!schema) return [null, input]
-
-  const { value, error } = schema.validate(input, {
-    ...defaultOptions,
-    ...options,
-  })
-
-  const err = error ? createError(input, error, inputName) : null
-  return [err, value]
-}
-
-/**
- * Convenience function that returns true if !error.
- */
-export function isValid<T>(input: T, schema?: AnySchema<T>): boolean {
-  if (!schema) return true
-
-  const { error } = schema.validate(input, defaultOptions)
-  return !error
-}
-
-export function undefinedIfInvalid<T>(input: any, schema?: AnySchema<T>): T | undefined {
-  if (!schema) return input
-
-  const { value, error } = schema.validate(input, defaultOptions)
-
-  return error ? undefined : value
-}
-
-/**
- * Will do joi-conversion, regardless of error/validity of value.
- *
- * @returns converted value
- */
-export function convert<T>(input: any, schema?: AnySchema<T>): T {
-  if (!schema) return input
-  const { value } = schema.validate(input, defaultOptions)
-  return value
-}
-
-function createError(value: any, err: ValidationError, inputName?: string): JoiValidationError {
-  const tokens: string[] = []
-
-  const inputId = _isObject(value) ? (value['id'] as string) : undefined
-
-  if (inputId || inputName) {
-    inputName ||= value?.constructor?.name
-
-    tokens.push('Invalid ' + [inputName, inputId].filter(Boolean).join('.'))
-  }
-
-  const annotation = err.annotate(stripColors)
-
-  if (annotation.length > 100) {
-    // For rather large annotations - we include up to 5 errors up front, before printing the whole object.
-
-    // Up to 5 `details`
-    tokens.push(
-      ...err.details.slice(0, 5).map(i => {
-        return i.message
-        // Currently not specifying the path, to not "overwhelm" the message
-        // Can be reverted if needed.
-        // let msg = i.message
-        // const paths = i.path.filter(Boolean).join('.')
-        // if (paths) msg += ` @ .${paths}`
-        // return msg
-      }),
-    )
-
-    if (err.details.length > 5) tokens.push(`... ${err.details.length} errors in total`)
-    tokens.push('')
-  }
-
-  tokens.push(
-    _truncateMiddle(annotation, 4000, `\n... ${_hb(annotation.length)} message truncated ...\n`),
-  )
-
-  const msg = tokens.join('\n')
-
-  const data: JoiValidationErrorData = {
-    joiValidationErrorItems: err.details,
-    ...(inputName && { joiValidationInputName: inputName }),
-    ...(inputId && { joiValidationInputId: inputId }),
-  }
-
-  // Make annotation non-enumerable, to not get it automatically printed,
-  // but still accessible
-  Object.defineProperty(data, 'annotation', {
-    writable: true,
-    configurable: true,
-    enumerable: false,
-    value: annotation,
-  })
-
-  return new JoiValidationError(msg, data)
-}

package/src/validation/joi/number.extensions.ts

@@ -1,46 +0,0 @@
-import type Joi from 'joi'
-import type { Extension, NumberSchema as JoiNumberSchema } from 'joi'
-
-export interface NumberSchema<TSchema = number> extends JoiNumberSchema<TSchema> {
-  dividable: (q: number) => this
-}
-
-export function numberExtensions(joi: typeof Joi): Extension {
-  return {
-    base: joi.number(),
-    type: 'number',
-    messages: {
-      'number.dividable': `"{{#label}}" must be dividable by {{#q}}`,
-    },
-    // validate (v, helpers) {
-    //   console.log('number validate called', {v})
-    // },
-    rules: {
-      // Based on: https://github.com/hapijs/joi/blob/master/API.md#extensions
-      dividable: {
-        multi: true,
-        method(q: number) {
-          return this.$_addRule({
-            name: 'dividable',
-            args: { q },
-          })
-        },
-        args: [
-          {
-            name: 'q',
-            ref: true,
-            assert: v => typeof v === 'number' && !Number.isNaN(v),
-            message: 'must be a number',
-          },
-        ],
-        validate(v: number, helpers, args) {
-          if (v % args['q'] === 0) {
-            return v
-          }
-
-          return helpers.error('number.dividable', args)
-        },
-      },
-    },
-  }
-}