@nikovirtala/projen-constructs 0.2.0 → 0.2.2

package/node_modules/ajv/lib/compile/names.ts

@@ -0,0 +1,27 @@
+import {Name} from "./codegen"
+
+const names = {
+  // validation function arguments
+  data: new Name("data"), // data passed to validation function
+  // args passed from referencing schema
+  valCxt: new Name("valCxt"), // validation/data context - should not be used directly, it is destructured to the names below
+  instancePath: new Name("instancePath"),
+  parentData: new Name("parentData"),
+  parentDataProperty: new Name("parentDataProperty"),
+  rootData: new Name("rootData"), // root data - same as the data passed to the first/top validation function
+  dynamicAnchors: new Name("dynamicAnchors"), // used to support recursiveRef and dynamicRef
+  // function scoped variables
+  vErrors: new Name("vErrors"), // null or array of validation errors
+  errors: new Name("errors"), // counter of validation errors
+  this: new Name("this"),
+  // "globals"
+  self: new Name("self"),
+  scope: new Name("scope"),
+  // JTD serialize/parse name for JSON string and position
+  json: new Name("json"),
+  jsonPos: new Name("jsonPos"),
+  jsonLen: new Name("jsonLen"),
+  jsonPart: new Name("jsonPart"),
+}
+
+export default names

package/node_modules/ajv/lib/compile/ref_error.ts

@@ -0,0 +1,13 @@
+import {resolveUrl, normalizeId, getFullPath} from "./resolve"
+import type {UriResolver} from "../types"
+
+export default class MissingRefError extends Error {
+  readonly missingRef: string
+  readonly missingSchema: string
+
+  constructor(resolver: UriResolver, baseId: string, ref: string, msg?: string) {
+    super(msg || `can't resolve reference ${ref} from id ${baseId}`)
+    this.missingRef = resolveUrl(resolver, baseId, ref)
+    this.missingSchema = normalizeId(getFullPath(resolver, this.missingRef))
+  }
+}

package/node_modules/ajv/lib/compile/resolve.ts

@@ -0,0 +1,149 @@
+import type {AnySchema, AnySchemaObject, UriResolver} from "../types"
+import type Ajv from "../ajv"
+import type {URIComponent} from "fast-uri"
+import {eachItem} from "./util"
+import * as equal from "fast-deep-equal"
+import * as traverse from "json-schema-traverse"
+
+// the hash of local references inside the schema (created by getSchemaRefs), used for inline resolution
+export type LocalRefs = {[Ref in string]?: AnySchemaObject}
+
+// TODO refactor to use keyword definitions
+const SIMPLE_INLINED = new Set([
+  "type",
+  "format",
+  "pattern",
+  "maxLength",
+  "minLength",
+  "maxProperties",
+  "minProperties",
+  "maxItems",
+  "minItems",
+  "maximum",
+  "minimum",
+  "uniqueItems",
+  "multipleOf",
+  "required",
+  "enum",
+  "const",
+])
+
+export function inlineRef(schema: AnySchema, limit: boolean | number = true): boolean {
+  if (typeof schema == "boolean") return true
+  if (limit === true) return !hasRef(schema)
+  if (!limit) return false
+  return countKeys(schema) <= limit
+}
+
+const REF_KEYWORDS = new Set([
+  "$ref",
+  "$recursiveRef",
+  "$recursiveAnchor",
+  "$dynamicRef",
+  "$dynamicAnchor",
+])
+
+function hasRef(schema: AnySchemaObject): boolean {
+  for (const key in schema) {
+    if (REF_KEYWORDS.has(key)) return true
+    const sch = schema[key]
+    if (Array.isArray(sch) && sch.some(hasRef)) return true
+    if (typeof sch == "object" && hasRef(sch)) return true
+  }
+  return false
+}
+
+function countKeys(schema: AnySchemaObject): number {
+  let count = 0
+  for (const key in schema) {
+    if (key === "$ref") return Infinity
+    count++
+    if (SIMPLE_INLINED.has(key)) continue
+    if (typeof schema[key] == "object") {
+      eachItem(schema[key], (sch) => (count += countKeys(sch)))
+    }
+    if (count === Infinity) return Infinity
+  }
+  return count
+}
+
+export function getFullPath(resolver: UriResolver, id = "", normalize?: boolean): string {
+  if (normalize !== false) id = normalizeId(id)
+  const p = resolver.parse(id)
+  return _getFullPath(resolver, p)
+}
+
+export function _getFullPath(resolver: UriResolver, p: URIComponent): string {
+  const serialized = resolver.serialize(p)
+  return serialized.split("#")[0] + "#"
+}
+
+const TRAILING_SLASH_HASH = /#\/?$/
+export function normalizeId(id: string | undefined): string {
+  return id ? id.replace(TRAILING_SLASH_HASH, "") : ""
+}
+
+export function resolveUrl(resolver: UriResolver, baseId: string, id: string): string {
+  id = normalizeId(id)
+  return resolver.resolve(baseId, id)
+}
+
+const ANCHOR = /^[a-z_][-a-z0-9._]*$/i
+
+export function getSchemaRefs(this: Ajv, schema: AnySchema, baseId: string): LocalRefs {
+  if (typeof schema == "boolean") return {}
+  const {schemaId, uriResolver} = this.opts
+  const schId = normalizeId(schema[schemaId] || baseId)
+  const baseIds: {[JsonPtr in string]?: string} = {"": schId}
+  const pathPrefix = getFullPath(uriResolver, schId, false)
+  const localRefs: LocalRefs = {}
+  const schemaRefs: Set<string> = new Set()
+
+  traverse(schema, {allKeys: true}, (sch, jsonPtr, _, parentJsonPtr) => {
+    if (parentJsonPtr === undefined) return
+    const fullPath = pathPrefix + jsonPtr
+    let innerBaseId = baseIds[parentJsonPtr]
+    if (typeof sch[schemaId] == "string") innerBaseId = addRef.call(this, sch[schemaId])
+    addAnchor.call(this, sch.$anchor)
+    addAnchor.call(this, sch.$dynamicAnchor)
+    baseIds[jsonPtr] = innerBaseId
+
+    function addRef(this: Ajv, ref: string): string {
+      // eslint-disable-next-line @typescript-eslint/unbound-method
+      const _resolve = this.opts.uriResolver.resolve
+      ref = normalizeId(innerBaseId ? _resolve(innerBaseId, ref) : ref)
+      if (schemaRefs.has(ref)) throw ambiguos(ref)
+      schemaRefs.add(ref)
+      let schOrRef = this.refs[ref]
+      if (typeof schOrRef == "string") schOrRef = this.refs[schOrRef]
+      if (typeof schOrRef == "object") {
+        checkAmbiguosRef(sch, schOrRef.schema, ref)
+      } else if (ref !== normalizeId(fullPath)) {
+        if (ref[0] === "#") {
+          checkAmbiguosRef(sch, localRefs[ref], ref)
+          localRefs[ref] = sch
+        } else {
+          this.refs[ref] = fullPath
+        }
+      }
+      return ref
+    }
+
+    function addAnchor(this: Ajv, anchor: unknown): void {
+      if (typeof anchor == "string") {
+        if (!ANCHOR.test(anchor)) throw new Error(`invalid anchor "${anchor}"`)
+        addRef.call(this, `#${anchor}`)
+      }
+    }
+  })
+
+  return localRefs
+
+  function checkAmbiguosRef(sch1: AnySchema, sch2: AnySchema | undefined, ref: string): void {
+    if (sch2 !== undefined && !equal(sch1, sch2)) throw ambiguos(ref)
+  }
+
+  function ambiguos(ref: string): Error {
+    return new Error(`reference "${ref}" resolves to more than one schema`)
+  }
+}

package/node_modules/ajv/lib/compile/rules.ts

@@ -0,0 +1,50 @@
+import type {AddedKeywordDefinition} from "../types"
+
+const _jsonTypes = ["string", "number", "integer", "boolean", "null", "object", "array"] as const
+
+export type JSONType = (typeof _jsonTypes)[number]
+
+const jsonTypes: Set<string> = new Set(_jsonTypes)
+
+export function isJSONType(x: unknown): x is JSONType {
+  return typeof x == "string" && jsonTypes.has(x)
+}
+
+type ValidationTypes = {
+  [K in JSONType]: boolean | RuleGroup | undefined
+}
+
+export interface ValidationRules {
+  rules: RuleGroup[]
+  post: RuleGroup
+  all: {[Key in string]?: boolean | Rule} // rules that have to be validated
+  keywords: {[Key in string]?: boolean} // all known keywords (superset of "all")
+  types: ValidationTypes
+}
+
+export interface RuleGroup {
+  type?: JSONType
+  rules: Rule[]
+}
+
+// This interface wraps KeywordDefinition because definition can have multiple keywords
+export interface Rule {
+  keyword: string
+  definition: AddedKeywordDefinition
+}
+
+export function getRules(): ValidationRules {
+  const groups: Record<"number" | "string" | "array" | "object", RuleGroup> = {
+    number: {type: "number", rules: []},
+    string: {type: "string", rules: []},
+    array: {type: "array", rules: []},
+    object: {type: "object", rules: []},
+  }
+  return {
+    types: {...groups, integer: true, boolean: true, null: true},
+    rules: [{rules: []}, groups.number, groups.string, groups.array, groups.object],
+    post: {rules: []},
+    all: {},
+    keywords: {},
+  }
+}

package/node_modules/ajv/lib/compile/util.ts

@@ -0,0 +1,213 @@
+import type {AnySchema, EvaluatedProperties, EvaluatedItems} from "../types"
+import type {SchemaCxt, SchemaObjCxt} from "."
+import {_, getProperty, Code, Name, CodeGen} from "./codegen"
+import {_Code} from "./codegen/code"
+import type {Rule, ValidationRules} from "./rules"
+
+// TODO refactor to use Set
+export function toHash<T extends string = string>(arr: T[]): {[K in T]?: true} {
+  const hash: {[K in T]?: true} = {}
+  for (const item of arr) hash[item] = true
+  return hash
+}
+
+export function alwaysValidSchema(it: SchemaCxt, schema: AnySchema): boolean | void {
+  if (typeof schema == "boolean") return schema
+  if (Object.keys(schema).length === 0) return true
+  checkUnknownRules(it, schema)
+  return !schemaHasRules(schema, it.self.RULES.all)
+}
+
+export function checkUnknownRules(it: SchemaCxt, schema: AnySchema = it.schema): void {
+  const {opts, self} = it
+  if (!opts.strictSchema) return
+  if (typeof schema === "boolean") return
+  const rules = self.RULES.keywords
+  for (const key in schema) {
+    if (!rules[key]) checkStrictMode(it, `unknown keyword: "${key}"`)
+  }
+}
+
+export function schemaHasRules(
+  schema: AnySchema,
+  rules: {[Key in string]?: boolean | Rule}
+): boolean {
+  if (typeof schema == "boolean") return !schema
+  for (const key in schema) if (rules[key]) return true
+  return false
+}
+
+export function schemaHasRulesButRef(schema: AnySchema, RULES: ValidationRules): boolean {
+  if (typeof schema == "boolean") return !schema
+  for (const key in schema) if (key !== "$ref" && RULES.all[key]) return true
+  return false
+}
+
+export function schemaRefOrVal(
+  {topSchemaRef, schemaPath}: SchemaObjCxt,
+  schema: unknown,
+  keyword: string,
+  $data?: string | false
+): Code | number | boolean {
+  if (!$data) {
+    if (typeof schema == "number" || typeof schema == "boolean") return schema
+    if (typeof schema == "string") return _`${schema}`
+  }
+  return _`${topSchemaRef}${schemaPath}${getProperty(keyword)}`
+}
+
+export function unescapeFragment(str: string): string {
+  return unescapeJsonPointer(decodeURIComponent(str))
+}
+
+export function escapeFragment(str: string | number): string {
+  return encodeURIComponent(escapeJsonPointer(str))
+}
+
+export function escapeJsonPointer(str: string | number): string {
+  if (typeof str == "number") return `${str}`
+  return str.replace(/~/g, "~0").replace(/\//g, "~1")
+}
+
+export function unescapeJsonPointer(str: string): string {
+  return str.replace(/~1/g, "/").replace(/~0/g, "~")
+}
+
+export function eachItem<T>(xs: T | T[], f: (x: T) => void): void {
+  if (Array.isArray(xs)) {
+    for (const x of xs) f(x)
+  } else {
+    f(xs)
+  }
+}
+
+type SomeEvaluated = EvaluatedProperties | EvaluatedItems
+
+type MergeEvaluatedFunc<T extends SomeEvaluated> = (
+  gen: CodeGen,
+  from: Name | T,
+  to: Name | Exclude<T, true> | undefined,
+  toName?: typeof Name
+) => Name | T
+
+interface MakeMergeFuncArgs<T extends SomeEvaluated> {
+  mergeNames: (gen: CodeGen, from: Name, to: Name) => void
+  mergeToName: (gen: CodeGen, from: T, to: Name) => void
+  mergeValues: (from: T, to: Exclude<T, true>) => T
+  resultToName: (gen: CodeGen, res?: T) => Name
+}
+
+function makeMergeEvaluated<T extends SomeEvaluated>({
+  mergeNames,
+  mergeToName,
+  mergeValues,
+  resultToName,
+}: MakeMergeFuncArgs<T>): MergeEvaluatedFunc<T> {
+  return (gen, from, to, toName) => {
+    const res =
+      to === undefined
+        ? from
+        : to instanceof Name
+        ? (from instanceof Name ? mergeNames(gen, from, to) : mergeToName(gen, from, to), to)
+        : from instanceof Name
+        ? (mergeToName(gen, to, from), from)
+        : mergeValues(from, to)
+    return toName === Name && !(res instanceof Name) ? resultToName(gen, res) : res
+  }
+}
+
+interface MergeEvaluated {
+  props: MergeEvaluatedFunc<EvaluatedProperties>
+  items: MergeEvaluatedFunc<EvaluatedItems>
+}
+
+export const mergeEvaluated: MergeEvaluated = {
+  props: makeMergeEvaluated({
+    mergeNames: (gen, from, to) =>
+      gen.if(_`${to} !== true && ${from} !== undefined`, () => {
+        gen.if(
+          _`${from} === true`,
+          () => gen.assign(to, true),
+          () => gen.assign(to, _`${to} || {}`).code(_`Object.assign(${to}, ${from})`)
+        )
+      }),
+    mergeToName: (gen, from, to) =>
+      gen.if(_`${to} !== true`, () => {
+        if (from === true) {
+          gen.assign(to, true)
+        } else {
+          gen.assign(to, _`${to} || {}`)
+          setEvaluated(gen, to, from)
+        }
+      }),
+    mergeValues: (from, to) => (from === true ? true : {...from, ...to}),
+    resultToName: evaluatedPropsToName,
+  }),
+  items: makeMergeEvaluated({
+    mergeNames: (gen, from, to) =>
+      gen.if(_`${to} !== true && ${from} !== undefined`, () =>
+        gen.assign(to, _`${from} === true ? true : ${to} > ${from} ? ${to} : ${from}`)
+      ),
+    mergeToName: (gen, from, to) =>
+      gen.if(_`${to} !== true`, () =>
+        gen.assign(to, from === true ? true : _`${to} > ${from} ? ${to} : ${from}`)
+      ),
+    mergeValues: (from, to) => (from === true ? true : Math.max(from, to)),
+    resultToName: (gen, items) => gen.var("items", items),
+  }),
+}
+
+export function evaluatedPropsToName(gen: CodeGen, ps?: EvaluatedProperties): Name {
+  if (ps === true) return gen.var("props", true)
+  const props = gen.var("props", _`{}`)
+  if (ps !== undefined) setEvaluated(gen, props, ps)
+  return props
+}
+
+export function setEvaluated(gen: CodeGen, props: Name, ps: {[K in string]?: true}): void {
+  Object.keys(ps).forEach((p) => gen.assign(_`${props}${getProperty(p)}`, true))
+}
+
+const snippets: {[S in string]?: _Code} = {}
+
+export function useFunc(gen: CodeGen, f: {code: string}): Name {
+  return gen.scopeValue("func", {
+    ref: f,
+    code: snippets[f.code] || (snippets[f.code] = new _Code(f.code)),
+  })
+}
+
+export enum Type {
+  Num,
+  Str,
+}
+
+export function getErrorPath(
+  dataProp: Name | string | number,
+  dataPropType?: Type,
+  jsPropertySyntax?: boolean
+): Code | string {
+  // let path
+  if (dataProp instanceof Name) {
+    const isNumber = dataPropType === Type.Num
+    return jsPropertySyntax
+      ? isNumber
+        ? _`"[" + ${dataProp} + "]"`
+        : _`"['" + ${dataProp} + "']"`
+      : isNumber
+      ? _`"/" + ${dataProp}`
+      : _`"/" + ${dataProp}.replace(/~/g, "~0").replace(/\\//g, "~1")` // TODO maybe use global escapePointer
+  }
+  return jsPropertySyntax ? getProperty(dataProp).toString() : "/" + escapeJsonPointer(dataProp)
+}
+
+export function checkStrictMode(
+  it: SchemaCxt,
+  msg: string,
+  mode: boolean | "log" = it.opts.strictSchema
+): void {
+  if (!mode) return
+  msg = `strict mode: ${msg}`
+  if (mode === true) throw new Error(msg)
+  it.self.logger.warn(msg)
+}

package/node_modules/ajv/lib/compile/validate/applicability.ts

@@ -0,0 +1,22 @@
+import type {AnySchemaObject} from "../../types"
+import type {SchemaObjCxt} from ".."
+import type {JSONType, RuleGroup, Rule} from "../rules"
+
+export function schemaHasRulesForType(
+  {schema, self}: SchemaObjCxt,
+  type: JSONType
+): boolean | undefined {
+  const group = self.RULES.types[type]
+  return group && group !== true && shouldUseGroup(schema, group)
+}
+
+export function shouldUseGroup(schema: AnySchemaObject, group: RuleGroup): boolean {
+  return group.rules.some((rule) => shouldUseRule(schema, rule))
+}
+
+export function shouldUseRule(schema: AnySchemaObject, rule: Rule): boolean | undefined {
+  return (
+    schema[rule.keyword] !== undefined ||
+    rule.definition.implements?.some((kwd) => schema[kwd] !== undefined)
+  )
+}

package/node_modules/ajv/lib/compile/validate/boolSchema.ts

@@ -0,0 +1,47 @@
+import type {KeywordErrorDefinition, KeywordErrorCxt} from "../../types"
+import type {SchemaCxt} from ".."
+import {reportError} from "../errors"
+import {_, Name} from "../codegen"
+import N from "../names"
+
+const boolError: KeywordErrorDefinition = {
+  message: "boolean schema is false",
+}
+
+export function topBoolOrEmptySchema(it: SchemaCxt): void {
+  const {gen, schema, validateName} = it
+  if (schema === false) {
+    falseSchemaError(it, false)
+  } else if (typeof schema == "object" && schema.$async === true) {
+    gen.return(N.data)
+  } else {
+    gen.assign(_`${validateName}.errors`, null)
+    gen.return(true)
+  }
+}
+
+export function boolOrEmptySchema(it: SchemaCxt, valid: Name): void {
+  const {gen, schema} = it
+  if (schema === false) {
+    gen.var(valid, false) // TODO var
+    falseSchemaError(it)
+  } else {
+    gen.var(valid, true) // TODO var
+  }
+}
+
+function falseSchemaError(it: SchemaCxt, overrideAllErrors?: boolean): void {
+  const {gen, data} = it
+  // TODO maybe some other interface should be used for non-keyword validation errors...
+  const cxt: KeywordErrorCxt = {
+    gen,
+    keyword: "false schema",
+    data,
+    schema: false,
+    schemaCode: false,
+    schemaValue: false,
+    params: {},
+    it,
+  }
+  reportError(cxt, boolError, undefined, overrideAllErrors)
+}