cdk-common 2.0.367 → 2.0.369

package/node_modules/table/node_modules/ajv/dist/vocabularies/unevaluated/unevaluatedItems.d.ts

@@ -1,5 +1,5 @@
 import type { CodeKeywordDefinition, ErrorObject, AnySchema } from "../../types";
-export declare type UnevaluatedItemsError = ErrorObject<"unevaluatedItems", {
+export type UnevaluatedItemsError = ErrorObject<"unevaluatedItems", {
     limit: number;
 }, AnySchema>;
 declare const def: CodeKeywordDefinition;

package/node_modules/table/node_modules/ajv/dist/vocabularies/unevaluated/unevaluatedProperties.d.ts

@@ -1,5 +1,5 @@
 import type { CodeKeywordDefinition, ErrorObject, AnySchema } from "../../types";
-export declare type UnevaluatedPropertiesError = ErrorObject<"unevaluatedProperties", {
+export type UnevaluatedPropertiesError = ErrorObject<"unevaluatedProperties", {
     unevaluatedProperty: string;
 }, AnySchema>;
 declare const def: CodeKeywordDefinition;

package/node_modules/table/node_modules/ajv/dist/vocabularies/validation/const.d.ts

@@ -1,5 +1,5 @@
 import type { CodeKeywordDefinition, ErrorObject } from "../../types";
-export declare type ConstError = ErrorObject<"const", {
+export type ConstError = ErrorObject<"const", {
     allowedValue: any;
 }>;
 declare const def: CodeKeywordDefinition;

package/node_modules/table/node_modules/ajv/dist/vocabularies/validation/dependentRequired.d.ts

@@ -1,5 +1,5 @@
 import type { CodeKeywordDefinition, ErrorObject } from "../../types";
 import { DependenciesErrorParams, PropertyDependencies } from "../applicator/dependencies";
-export declare type DependentRequiredError = ErrorObject<"dependentRequired", DependenciesErrorParams, PropertyDependencies>;
+export type DependentRequiredError = ErrorObject<"dependentRequired", DependenciesErrorParams, PropertyDependencies>;
 declare const def: CodeKeywordDefinition;
 export default def;

package/node_modules/table/node_modules/ajv/dist/vocabularies/validation/enum.d.ts

@@ -1,5 +1,5 @@
 import type { CodeKeywordDefinition, ErrorObject } from "../../types";
-export declare type EnumError = ErrorObject<"enum", {
+export type EnumError = ErrorObject<"enum", {
     allowedValues: any[];
 }, any[] | {
     $data: string;

package/node_modules/table/node_modules/ajv/dist/vocabularies/validation/index.d.ts

@@ -8,9 +8,9 @@ import { ConstError } from "./const";
 import { EnumError } from "./enum";
 declare const validation: Vocabulary;
 export default validation;
-declare type LimitError = ErrorObject<"maxItems" | "minItems" | "minProperties" | "maxProperties" | "minLength" | "maxLength", {
+type LimitError = ErrorObject<"maxItems" | "minItems" | "minProperties" | "maxProperties" | "minLength" | "maxLength", {
     limit: number;
 }, number | {
     $data: string;
 }>;
-export declare type ValidationKeywordError = LimitError | LimitNumberError | MultipleOfError | PatternError | RequiredError | UniqueItemsError | ConstError | EnumError;
+export type ValidationKeywordError = LimitError | LimitNumberError | MultipleOfError | PatternError | RequiredError | UniqueItemsError | ConstError | EnumError;

package/node_modules/table/node_modules/ajv/dist/vocabularies/validation/limitNumber.d.ts

@@ -1,7 +1,7 @@
 import type { CodeKeywordDefinition, ErrorObject } from "../../types";
-declare type Kwd = "maximum" | "minimum" | "exclusiveMaximum" | "exclusiveMinimum";
-declare type Comparison = "<=" | ">=" | "<" | ">";
-export declare type LimitNumberError = ErrorObject<Kwd, {
+type Kwd = "maximum" | "minimum" | "exclusiveMaximum" | "exclusiveMinimum";
+type Comparison = "<=" | ">=" | "<" | ">";
+export type LimitNumberError = ErrorObject<Kwd, {
     limit: number;
     comparison: Comparison;
 }, number | {

package/node_modules/table/node_modules/ajv/dist/vocabularies/validation/multipleOf.d.ts

@@ -1,5 +1,5 @@
 import type { CodeKeywordDefinition, ErrorObject } from "../../types";
-export declare type MultipleOfError = ErrorObject<"multipleOf", {
+export type MultipleOfError = ErrorObject<"multipleOf", {
     multipleOf: number;
 }, number | {
     $data: string;

package/node_modules/table/node_modules/ajv/dist/vocabularies/validation/pattern.d.ts

@@ -1,5 +1,5 @@
 import type { CodeKeywordDefinition, ErrorObject } from "../../types";
-export declare type PatternError = ErrorObject<"pattern", {
+export type PatternError = ErrorObject<"pattern", {
     pattern: string;
 }, string | {
     $data: string;

package/node_modules/table/node_modules/ajv/dist/vocabularies/validation/required.d.ts

@@ -1,5 +1,5 @@
 import type { CodeKeywordDefinition, ErrorObject } from "../../types";
-export declare type RequiredError = ErrorObject<"required", {
+export type RequiredError = ErrorObject<"required", {
     missingProperty: string;
 }, string[] | {
     $data: string;

package/node_modules/table/node_modules/ajv/dist/vocabularies/validation/uniqueItems.d.ts

@@ -1,5 +1,5 @@
 import type { CodeKeywordDefinition, ErrorObject } from "../../types";
-export declare type UniqueItemsError = ErrorObject<"uniqueItems", {
+export type UniqueItemsError = ErrorObject<"uniqueItems", {
     i: number;
     j: number;
 }, boolean | {

package/node_modules/table/node_modules/ajv/lib/compile/jtd/serialize.ts

@@ -117,7 +117,7 @@ function serializeValues(cxt: SerializeCxt): void {
   gen.add(N.json, str`}`)
 }
 
-function serializeKeyValue(cxt: SerializeCxt, key: Name, schema: SchemaObject, first: Name): void {
+function serializeKeyValue(cxt: SerializeCxt, key: Name, schema: SchemaObject, first?: Name): void {
   const {gen, data} = cxt
   addComma(cxt, first)
   serializeString({...cxt, data: key})
@@ -156,20 +156,24 @@ function serializeSchemaProperties(cxt: SerializeCxt, discriminator?: string): v
   const optProps = keys(optionalProperties)
   const allProps = allProperties(props.concat(optProps))
   let first = !discriminator
+  let firstProp: Name | undefined
+
   for (const key of props) {
+    if (first) first = false
+    else gen.add(N.json, str`,`)
     serializeProperty(key, properties[key], keyValue(key))
   }
+  if (first) firstProp = gen.let("first", true)
   for (const key of optProps) {
     const value = keyValue(key)
-    gen.if(and(_`${value} !== undefined`, isOwnProperty(gen, data, key)), () =>
+    gen.if(and(_`${value} !== undefined`, isOwnProperty(gen, data, key)), () => {
+      addComma(cxt, firstProp)
       serializeProperty(key, optionalProperties[key], value)
-    )
+    })
   }
   if (schema.additionalProperties) {
     gen.forIn("key", data, (key) =>
-      gen.if(isAdditional(key, allProps), () =>
-        serializeKeyValue(cxt, key, {}, gen.let("first", first))
-      )
+      gen.if(isAdditional(key, allProps), () => serializeKeyValue(cxt, key, {}, firstProp))
     )
   }
 
@@ -190,8 +194,6 @@ function serializeSchemaProperties(cxt: SerializeCxt, discriminator?: string): v
   }
 
   function serializeProperty(key: string, propSchema: SchemaObject, value: Name): void {
-    if (first) first = false
-    else gen.add(N.json, str`,`)
     gen.add(N.json, str`${JSON.stringify(key)}:`)
     serializeCode({...cxt, schema: propSchema, data: value})
   }
@@ -251,10 +253,14 @@ function serializeEmpty({gen, data}: SerializeCxt): void {
   gen.add(N.json, _`JSON.stringify(${data})`)
 }
 
-function addComma({gen}: SerializeCxt, first: Name): void {
-  gen.if(
-    first,
-    () => gen.assign(first, false),
-    () => gen.add(N.json, str`,`)
-  )
+function addComma({gen}: SerializeCxt, first?: Name): void {
+  if (first) {
+    gen.if(
+      first,
+      () => gen.assign(first, false),
+      () => gen.add(N.json, str`,`)
+    )
+  } else {
+    gen.add(N.json, str`,`)
+  }
 }

package/node_modules/table/node_modules/ajv/lib/compile/validate/index.ts

@@ -286,7 +286,7 @@ function checkContextTypes(it: SchemaObjCxt, types: JSONType[]): void {
       strictTypesError(it, `type "${t}" not allowed by context "${it.dataTypes.join(",")}"`)
     }
   })
-  it.dataTypes = it.dataTypes.filter((t) => includesType(types, t))
+  narrowSchemaTypes(it, types)
 }
 
 function checkMultipleTypes(it: SchemaObjCxt, ts: JSONType[]): void {
@@ -316,6 +316,15 @@ function includesType(ts: JSONType[], t: JSONType): boolean {
   return ts.includes(t) || (t === "integer" && ts.includes("number"))
 }
 
+function narrowSchemaTypes(it: SchemaObjCxt, withTypes: JSONType[]): void {
+  const ts: JSONType[] = []
+  for (const t of it.dataTypes) {
+    if (includesType(withTypes, t)) ts.push(t)
+    else if (withTypes.includes("integer") && t === "number") ts.push("integer")
+  }
+  it.dataTypes = ts
+}
+
 function strictTypesError(it: SchemaObjCxt, msg: string): void {
   const schemaPath = it.schemaEnv.baseId + it.errSchemaPath
   msg += ` at "${schemaPath}" (strictTypes)`

package/node_modules/table/node_modules/ajv/lib/types/jtd-schema.ts

@@ -74,7 +74,7 @@ type EnumString<T> = [T] extends [never]
   : null
 
 /** true if type is a union of string literals */
-type IsEnum<T> = null extends EnumString<Exclude<T, null>> ? false : true
+type IsEnum<T> = null extends EnumString<T> ? false : true
 
 /** true only if all types are array types (not tuples) */
 // NOTE relies on the fact that tuples don't have an index at 0.5, but arrays
@@ -88,13 +88,18 @@ type IsElements<T> = false extends IsUnion<T>
   : false
 
 /** true if the the type is a values type */
-type IsValues<T> = false extends IsUnion<Exclude<T, null>>
-  ? TypeEquality<keyof Exclude<T, null>, string>
+type IsValues<T> = false extends IsUnion<T> ? TypeEquality<keyof T, string> : false
+
+/** true if type is a properties type and Union is false, or type is a discriminator type and Union is true */
+type IsRecord<T, Union extends boolean> = Union extends IsUnion<T>
+  ? null extends EnumString<keyof T>
+    ? false
+    : true
   : false
 
-/** true if type is a proeprties type and Union is false, or type is a discriminator type and Union is true */
-type IsRecord<T, Union extends boolean> = Union extends IsUnion<Exclude<T, null>>
-  ? null extends EnumString<keyof Exclude<T, null>>
+/** true if type represents an empty record */
+type IsEmptyRecord<T> = [T] extends [Record<string, never>]
+  ? [T] extends [never]
     ? false
     : true
   : false
@@ -131,7 +136,7 @@ export type JTDSchemaType<T, D extends Record<string, unknown> = Record<string,
       ? {type: "timestamp"}
       : // enums - only accepts union of string literals
       // TODO we can't actually check that everything in the union was specified
-      true extends IsEnum<T>
+      true extends IsEnum<Exclude<T, null>>
       ? {enum: EnumString<Exclude<T, null>>[]}
       : // arrays - only accepts arrays, could be array of unions to be resolved later
       true extends IsElements<Exclude<T, null>>
@@ -140,15 +145,20 @@ export type JTDSchemaType<T, D extends Record<string, unknown> = Record<string,
             elements: JTDSchemaType<E, D>
           }
         : never
+      : // empty properties
+      true extends IsEmptyRecord<Exclude<T, null>>
+      ?
+          | {properties: Record<string, never>; optionalProperties?: Record<string, never>}
+          | {optionalProperties: Record<string, never>}
       : // values
-      true extends IsValues<T>
+      true extends IsValues<Exclude<T, null>>
       ? T extends Record<string, infer V>
         ? {
             values: JTDSchemaType<V, D>
           }
         : never
       : // properties
-      true extends IsRecord<T, false>
+      true extends IsRecord<Exclude<T, null>, false>
       ? ([RequiredKeys<Exclude<T, null>>] extends [never]
           ? {
               properties?: Record<string, never>
@@ -168,7 +178,7 @@ export type JTDSchemaType<T, D extends Record<string, unknown> = Record<string,
             additionalProperties?: boolean
           }
       : // discriminator
-      true extends IsRecord<T, true>
+      true extends IsRecord<Exclude<T, null>, true>
       ? {
           [K in keyof Exclude<T, null>]-?: Exclude<T, null>[K] extends string
             ? {
@@ -176,7 +186,7 @@ export type JTDSchemaType<T, D extends Record<string, unknown> = Record<string,
                 mapping: {
                   // TODO currently allows descriminator to be present in schema
                   [M in Exclude<T, null>[K]]: JTDSchemaType<
-                    Omit<T extends {[C in K]: M} ? T : never, K>,
+                    Omit<T extends Record<K, M> ? T : never, K>,
                     D
                   >
                 }

package/node_modules/table/node_modules/ajv/lib/vocabularies/jtd/properties.ts

@@ -138,9 +138,7 @@ export function validateProperties(cxt: KeywordCxt): void {
 
   function validateAdditional(): void {
     gen.forIn("key", data, (key: Name) => {
-      const _allProps =
-        it.jtdDiscriminator === undefined ? allProps : [it.jtdDiscriminator].concat(allProps)
-      const addProp = isAdditional(key, _allProps, "properties")
+      const addProp = isAdditional(key, allProps, "properties", it.jtdDiscriminator)
       const addOptProp = isAdditional(key, allOptProps, "optionalProperties")
       const extra =
         addProp === true ? addOptProp : addOptProp === true ? addProp : and(addProp, addOptProp)
@@ -159,14 +157,23 @@ export function validateProperties(cxt: KeywordCxt): void {
     })
   }
 
-  function isAdditional(key: Name, props: string[], keyword: string): Code | true {
+  function isAdditional(
+    key: Name,
+    props: string[],
+    keyword: string,
+    jtdDiscriminator?: string
+  ): Code | true {
     let additional: Code | boolean
     if (props.length > 8) {
       // TODO maybe an option instead of hard-coded 8?
       const propsSchema = schemaRefOrVal(it, parentSchema[keyword], keyword)
       additional = not(isOwnProperty(gen, propsSchema as Code, key))
-    } else if (props.length) {
-      additional = and(...props.map((p) => _`${key} !== ${p}`))
+      if (jtdDiscriminator !== undefined) {
+        additional = and(additional, _`${key} !== ${jtdDiscriminator}`)
+      }
+    } else if (props.length || jtdDiscriminator !== undefined) {
+      const ps = jtdDiscriminator === undefined ? props : [jtdDiscriminator].concat(props)
+      additional = and(...ps.map((p) => _`${key} !== ${p}`))
     } else {
       additional = true
     }

package/node_modules/table/node_modules/ajv/lib/vocabularies/jtd/values.ts

@@ -1,7 +1,7 @@
 import type {CodeKeywordDefinition, SchemaObject} from "../../types"
 import type {KeywordCxt} from "../../compile/validate"
 import {alwaysValidSchema, Type} from "../../compile/util"
-import {not, Name} from "../../compile/codegen"
+import {not, or, Name} from "../../compile/codegen"
 import {checkMetadata} from "./metadata"
 import {checkNullableObject} from "./nullable"
 import {typeError, _JTDTypeError} from "./error"
@@ -15,13 +15,16 @@ const def: CodeKeywordDefinition = {
   code(cxt: KeywordCxt) {
     checkMetadata(cxt)
     const {gen, data, schema, it} = cxt
-    if (alwaysValidSchema(it, schema)) return
     const [valid, cond] = checkNullableObject(cxt, data)
-    gen.if(cond)
-    gen.assign(valid, validateMap())
-    gen.elseIf(not(valid))
-    cxt.error()
-    gen.endIf()
+    if (alwaysValidSchema(it, schema)) {
+      gen.if(not(or(cond, valid)), () => cxt.error())
+    } else {
+      gen.if(cond)
+      gen.assign(valid, validateMap())
+      gen.elseIf(not(valid))
+      cxt.error()
+      gen.endIf()
+    }
     cxt.ok(valid)
 
     function validateMap(): Name | boolean {

package/node_modules/table/node_modules/ajv/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ajv",
-  "version": "8.11.2",
+  "version": "8.12.0",
   "description": "Another JSON Schema Validator",
   "main": "dist/ajv.js",
   "types": "dist/ajv.d.ts",
@@ -65,12 +65,12 @@
   },
   "devDependencies": {
     "@ajv-validator/config": "^0.3.0",
-    "@rollup/plugin-commonjs": "^23.0.2",
-    "@rollup/plugin-json": "^4.1.0",
+    "@rollup/plugin-commonjs": "^24.0.0",
+    "@rollup/plugin-json": "^6.0.0",
     "@rollup/plugin-node-resolve": "^15.0.1",
-    "@rollup/plugin-typescript": "^8.2.1",
+    "@rollup/plugin-typescript": "^10.0.1",
     "@types/chai": "^4.2.12",
-    "@types/mocha": "^9.0.0",
+    "@types/mocha": "^10.0.0",
     "@types/node": "^18.11.9",
     "@types/require-from-string": "^1.2.0",
     "@typescript-eslint/eslint-plugin": "^3.8.0",

package/package.json

@@ -55,7 +55,7 @@
     "jsii-pacmak": "^1.72.0",
     "json-schema": "^0.4.0",
     "npm-check-updates": "^16",
-    "projen": "0.65.78",
+    "projen": "0.65.80",
     "standard-version": "^9",
     "ts-jest": "^27",
     "typescript": "3.9.10"
@@ -65,7 +65,7 @@
     "constructs": "^10.0.5"
   },
   "dependencies": {
-    "@aws-cdk/assert": "^2.58.1",
+    "@aws-cdk/assert": "^2.59.0",
     "case": "^1.6.3",
     "sync-request": "^6.1.0"
   },
@@ -83,7 +83,7 @@
   ],
   "main": "lib/index.js",
   "license": "Apache-2.0",
-  "version": "2.0.367",
+  "version": "2.0.369",
   "jest": {
     "testMatch": [
       "<rootDir>/src/**/__tests__/**/*.ts?(x)",