验证在 Typescript 中具有动态密钥的 Json 架构

Question

I have a folder 'schemas' which contains different JSON files to store different schemas.

For example,

/schemas/apple-schema.json

{
  "$schema": "http://json-schema.org/draft-06/schema",
  "type": "object",
  "properties": {
    "apple_name": {
      "type": "string"
    },
    "id": {
      "type": "integer"
    },
    "apple_weight": {
      "type": "number"
    },
    "timestamp": {
      "type": "string",
      "format": "date-time"
    },
    "required": ["id"]
  }
}

/schemas/mango-schema.json

{
  "$schema": "http://json-schema.org/draft-06/schema",
  "type": "object",
  "properties": {
    "mango_name": {
      "type": "string"
    },
    "id": {
      "type": "integer"
    },
    "mango_mature": {
      "type": "number"
    },
    "mango_age": {
      "type": "number"
    },
    "mango_timestamp": {
      "type": "string",
      "format": "date-time"
    },
    "required": ["id"]
  }
}

Different schemas have different keys. What I want to validate is below:

1. Keys (eg apple_name, id, timestamp, mango_name, mango_mature, mango_age and etc) among all schemas are following the same naming convention (lowercase with an underscore: 'xxx' or 'xxx_yyy').

2. Any key whose name contains 'timestamp' should be in format 'date-time'

3. Any schema should exist key 'id'. (Key 'id' is required for all schemas)

Is it possible to write a unit test which imports all JSON schemas and handle the validations?

Answer 1

You need a JSON Schema Validator like Ajv to do the schema validation at runtime instead of the features of TypeScript.

You may want to write some type definitions for these fruits schema to help you coding under the type safety situation.

TypeScript provides static type checking, which stripped away at compile-time and do not exist at runtime. So you can't check the type at runtime.

---

According to your requirement:

1. Validating name convention

You can do it by a regular expression.

3. Any schema should exist key 'id'

Here is something TypeScript can offer you:

interface Schema {
  id: number;
}

interface AppleSchema extends Schema {
  apple_name: string,
  apple_weight: number,
  // rest properties...
}

interface MongoSchema extends Schema {
  mango_name: string,
  mango_mature: number,
  // rest properties...
}

// enjoy the power of TypeScript
export function testApple(apple: AppleSchema) {
  console.log(apple.id); // now you can access apple.id, apple.apple_name, apple.apple_weight ...
}

// even more
export function findFruit<T extends Schema>(fruits: T[], id: number) {
    return fruits.find(fruit => fruit.id === id)
}