@atproto/lexicon 0.0.1

package/src/validators/primitives.ts

@@ -0,0 +1,300 @@
+import { Lexicons } from '../lexicons'
+import {
+  LexUserType,
+  LexBoolean,
+  LexNumber,
+  LexInteger,
+  LexString,
+  LexDatetime,
+  ValidationResult,
+  ValidationError,
+} from '../types'
+
+export function validate(
+  lexicons: Lexicons,
+  path: string,
+  def: LexUserType,
+  value: unknown,
+): ValidationResult {
+  switch (def.type) {
+    case 'boolean':
+      return boolean(lexicons, path, def, value)
+    case 'number':
+      return number(lexicons, path, def, value)
+    case 'integer':
+      return integer(lexicons, path, def, value)
+    case 'string':
+      return string(lexicons, path, def, value)
+    case 'datetime':
+      return datetime(lexicons, path, def, value)
+    case 'unknown':
+      return unknown(lexicons, path, def, value)
+    default:
+      return {
+        success: false,
+        error: new ValidationError(`Unexpected lexicon type: ${def.type}`),
+      }
+  }
+}
+
+export function boolean(
+  lexicons: Lexicons,
+  path: string,
+  def: LexUserType,
+  value: unknown,
+): ValidationResult {
+  def = def as LexBoolean
+
+  // type
+  const type = typeof value
+  if (type == 'undefined') {
+    if (typeof def.default === 'boolean') {
+      return { success: true }
+    }
+    return {
+      success: false,
+      error: new ValidationError(`${path} must be a boolean`),
+    }
+  } else if (type !== 'boolean') {
+    return {
+      success: false,
+      error: new ValidationError(`${path} must be a boolean`),
+    }
+  }
+
+  // const
+  if (typeof def.const === 'boolean') {
+    if (value !== def.const) {
+      return {
+        success: false,
+        error: new ValidationError(`${path} must be ${def.const}`),
+      }
+    }
+  }
+
+  return { success: true }
+}
+
+export function number(
+  lexicons: Lexicons,
+  path: string,
+  def: LexUserType,
+  value: unknown,
+): ValidationResult {
+  def = def as LexNumber
+
+  // type
+  const type = typeof value
+  if (type == 'undefined') {
+    if (typeof def.default === 'number') {
+      return { success: true }
+    }
+    return {
+      success: false,
+      error: new ValidationError(`${path} must be a number`),
+    }
+  } else if (type !== 'number') {
+    return {
+      success: false,
+      error: new ValidationError(`${path} must be a number`),
+    }
+  }
+
+  // const
+  if (typeof def.const === 'number') {
+    if (value !== def.const) {
+      return {
+        success: false,
+        error: new ValidationError(`${path} must be ${def.const}`),
+      }
+    }
+  }
+
+  // enum
+  if (Array.isArray(def.enum)) {
+    if (!def.enum.includes(value as number)) {
+      return {
+        success: false,
+        error: new ValidationError(
+          `${path} must be one of (${def.enum.join('|')})`,
+        ),
+      }
+    }
+  }
+
+  // maximum
+  if (typeof def.maximum === 'number') {
+    if ((value as number) > def.maximum) {
+      return {
+        success: false,
+        error: new ValidationError(
+          `${path} can not be greater than ${def.maximum}`,
+        ),
+      }
+    }
+  }
+
+  // minimum
+  if (typeof def.minimum === 'number') {
+    if ((value as number) < def.minimum) {
+      return {
+        success: false,
+        error: new ValidationError(
+          `${path} can not be less than ${def.minimum}`,
+        ),
+      }
+    }
+  }
+
+  return { success: true }
+}
+
+export function integer(
+  lexicons: Lexicons,
+  path: string,
+  def: LexUserType,
+  value: unknown,
+): ValidationResult {
+  def = def as LexInteger
+
+  // run number validation
+  const numRes = number(lexicons, path, def, value)
+  if (!numRes.success) {
+    return numRes
+  }
+
+  // whole numbers only
+  if (!Number.isInteger(value)) {
+    return {
+      success: false,
+      error: new ValidationError(`${path} must be an integer`),
+    }
+  }
+
+  return { success: true }
+}
+
+export function string(
+  lexicons: Lexicons,
+  path: string,
+  def: LexUserType,
+  value: unknown,
+): ValidationResult {
+  def = def as LexString
+
+  // type
+  const type = typeof value
+  if (type == 'undefined') {
+    if (typeof def.default === 'string') {
+      return { success: true }
+    }
+    return {
+      success: false,
+      error: new ValidationError(`${path} must be a string`),
+    }
+  } else if (type !== 'string') {
+    return {
+      success: false,
+      error: new ValidationError(`${path} must be a string`),
+    }
+  }
+
+  // const
+  if (typeof def.const === 'string') {
+    if (value !== def.const) {
+      return {
+        success: false,
+        error: new ValidationError(`${path} must be ${def.const}`),
+      }
+    }
+  }
+
+  // enum
+  if (Array.isArray(def.enum)) {
+    if (!def.enum.includes(value as string)) {
+      return {
+        success: false,
+        error: new ValidationError(
+          `${path} must be one of (${def.enum.join('|')})`,
+        ),
+      }
+    }
+  }
+
+  // maxLength
+  if (typeof def.maxLength === 'number') {
+    if ((value as string).length > def.maxLength) {
+      return {
+        success: false,
+        error: new ValidationError(
+          `${path} must not be longer than ${def.maxLength} characters`,
+        ),
+      }
+    }
+  }
+
+  // minLength
+  if (typeof def.minLength === 'number') {
+    if ((value as string).length < def.minLength) {
+      return {
+        success: false,
+        error: new ValidationError(
+          `${path} must not be shorter than ${def.minLength} characters`,
+        ),
+      }
+    }
+  }
+
+  return { success: true }
+}
+
+export function datetime(
+  lexicons: Lexicons,
+  path: string,
+  def: LexUserType,
+  value: unknown,
+): ValidationResult {
+  def = def as LexDatetime
+
+  // type
+  const type = typeof value
+  if (type !== 'string') {
+    return {
+      success: false,
+      error: new ValidationError(`${path} must be a string`),
+    }
+  }
+
+  // valid iso-8601
+  {
+    try {
+      const date = new Date(Date.parse(value as string))
+      if (value !== date.toISOString()) {
+        throw new ValidationError(
+          `${path} must be an iso8601 formatted datetime`,
+        )
+      }
+    } catch {
+      throw new ValidationError(`${path} must be an iso8601 formatted datetime`)
+    }
+  }
+
+  return { success: true }
+}
+
+export function unknown(
+  lexicons: Lexicons,
+  path: string,
+  def: LexUserType,
+  value: unknown,
+): ValidationResult {
+  // type
+  if (!value || typeof value !== 'object') {
+    return {
+      success: false,
+      error: new ValidationError(`${path} must be an object`),
+    }
+  }
+
+  return { success: true }
+}

package/src/validators/xrpc.ts

@@ -0,0 +1,50 @@
+import { Lexicons } from '../lexicons'
+import { LexXrpcParameters, ValidationResult, ValidationError } from '../types'
+
+import * as PrimitiveValidators from './primitives'
+
+export function params(
+  lexicons: Lexicons,
+  path: string,
+  def: LexXrpcParameters,
+  value: unknown,
+): ValidationResult {
+  def = def as LexXrpcParameters
+
+  // type
+  if (!value || typeof value !== 'object') {
+    // in this case, we just fall back to an object
+    value = {}
+  }
+
+  // required
+  if (Array.isArray(def.required)) {
+    for (const key of def.required) {
+      if (!(key in (value as Record<string, unknown>))) {
+        return {
+          success: false,
+          error: new ValidationError(`${path} must have the property "${key}"`),
+        }
+      }
+    }
+  }
+
+  // properties
+  for (const key in def.properties) {
+    if (typeof (value as Record<string, unknown>)[key] === 'undefined') {
+      continue // skip- if required, will have already failed
+    }
+    const paramDef = def.properties[key]
+    const res = PrimitiveValidators.validate(
+      lexicons,
+      key,
+      paramDef,
+      (value as Record<string, unknown>)[key],
+    )
+    if (!res.success) {
+      return res
+    }
+  }
+
+  return { success: true }
+}

package/tests/_scaffolds/lexicons.ts

@@ -0,0 +1,379 @@
+export default [
+  {
+    lexicon: 1,
+    id: 'com.example.kitchenSink',
+    defs: {
+      main: {
+        type: 'record',
+        description: 'A record',
+        key: 'tid',
+        record: {
+          type: 'object',
+          required: [
+            'object',
+            'array',
+            'boolean',
+            'number',
+            'integer',
+            'string',
+            'datetime',
+          ],
+          properties: {
+            object: { type: 'ref', ref: '#object' },
+            array: { type: 'array', items: { type: 'string' } },
+            boolean: { type: 'boolean' },
+            number: { type: 'number' },
+            integer: { type: 'integer' },
+            string: { type: 'string' },
+            datetime: { type: 'datetime' },
+          },
+        },
+      },
+      object: {
+        type: 'object',
+        required: ['object', 'array', 'boolean', 'number', 'integer', 'string'],
+        properties: {
+          object: { type: 'ref', ref: '#subobject' },
+          array: { type: 'array', items: { type: 'string' } },
+          boolean: { type: 'boolean' },
+          number: { type: 'number' },
+          integer: { type: 'integer' },
+          string: { type: 'string' },
+        },
+      },
+      subobject: {
+        type: 'object',
+        required: ['boolean'],
+        properties: {
+          boolean: { type: 'boolean' },
+        },
+      },
+    },
+  },
+  {
+    lexicon: 1,
+    id: 'com.example.query',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'A query',
+        parameters: {
+          type: 'params',
+          required: ['boolean', 'number', 'integer'],
+          properties: {
+            boolean: { type: 'boolean' },
+            number: { type: 'number' },
+            integer: { type: 'integer' },
+            string: { type: 'string' },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: { type: 'ref', ref: 'com.example.kitchenSink#object' },
+        },
+      },
+    },
+  },
+  {
+    lexicon: 1,
+    id: 'com.example.procedure',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'A procedure',
+        parameters: {
+          type: 'params',
+          required: ['boolean', 'number', 'integer'],
+          properties: {
+            boolean: { type: 'boolean' },
+            number: { type: 'number' },
+            integer: { type: 'integer' },
+            string: { type: 'string' },
+          },
+        },
+        input: {
+          encoding: 'application/json',
+          schema: { type: 'ref', ref: 'com.example.kitchenSink#object' },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: { type: 'ref', ref: 'com.example.kitchenSink#object' },
+        },
+      },
+    },
+  },
+  {
+    lexicon: 1,
+    id: 'com.example.optional',
+    defs: {
+      main: {
+        type: 'record',
+        record: {
+          type: 'object',
+          properties: {
+            object: { type: 'ref', ref: 'com.example.kitchenSink#object' },
+            array: { type: 'array', items: { type: 'string' } },
+            boolean: { type: 'boolean' },
+            number: { type: 'number' },
+            integer: { type: 'integer' },
+            string: { type: 'string' },
+          },
+        },
+      },
+    },
+  },
+  {
+    lexicon: 1,
+    id: 'com.example.union',
+    defs: {
+      main: {
+        type: 'record',
+        description: 'A record',
+        key: 'tid',
+        record: {
+          type: 'object',
+          required: ['unionOpen', 'unionClosed'],
+          properties: {
+            unionOpen: {
+              type: 'union',
+              refs: [
+                'com.example.kitchenSink#object',
+                'com.example.kitchenSink#subobject',
+              ],
+            },
+            unionClosed: {
+              type: 'union',
+              closed: true,
+              refs: [
+                'com.example.kitchenSink#object',
+                'com.example.kitchenSink#subobject',
+              ],
+            },
+          },
+        },
+      },
+    },
+  },
+  {
+    lexicon: 1,
+    id: 'com.example.unknown',
+    defs: {
+      main: {
+        type: 'record',
+        description: 'A record',
+        key: 'tid',
+        record: {
+          type: 'object',
+          required: ['unknown'],
+          properties: {
+            unknown: { type: 'unknown' },
+            optUnknown: { type: 'unknown' },
+          },
+        },
+      },
+    },
+  },
+  {
+    lexicon: 1,
+    id: 'com.example.arrayLength',
+    defs: {
+      main: {
+        type: 'record',
+        record: {
+          type: 'object',
+          properties: {
+            array: {
+              type: 'array',
+              minLength: 2,
+              maxLength: 4,
+              items: { type: 'number' },
+            },
+          },
+        },
+      },
+    },
+  },
+  {
+    lexicon: 1,
+    id: 'com.example.boolConst',
+    defs: {
+      main: {
+        type: 'record',
+        record: {
+          type: 'object',
+          properties: {
+            boolean: {
+              type: 'boolean',
+              const: false,
+            },
+          },
+        },
+      },
+    },
+  },
+  {
+    lexicon: 1,
+    id: 'com.example.numberRange',
+    defs: {
+      main: {
+        type: 'record',
+        record: {
+          type: 'object',
+          properties: {
+            number: {
+              type: 'number',
+              minimum: 2,
+              maximum: 4,
+            },
+          },
+        },
+      },
+    },
+  },
+  {
+    lexicon: 1,
+    id: 'com.example.numberEnum',
+    defs: {
+      main: {
+        type: 'record',
+        record: {
+          type: 'object',
+          properties: {
+            number: {
+              type: 'number',
+              enum: [1, 1.5, 2],
+            },
+          },
+        },
+      },
+    },
+  },
+  {
+    lexicon: 1,
+    id: 'com.example.numberConst',
+    defs: {
+      main: {
+        type: 'record',
+        record: {
+          type: 'object',
+          properties: {
+            number: {
+              type: 'number',
+              const: 0,
+            },
+          },
+        },
+      },
+    },
+  },
+  {
+    lexicon: 1,
+    id: 'com.example.integerRange',
+    defs: {
+      main: {
+        type: 'record',
+        record: {
+          type: 'object',
+          properties: {
+            integer: {
+              type: 'integer',
+              minimum: 2,
+              maximum: 4,
+            },
+          },
+        },
+      },
+    },
+  },
+  {
+    lexicon: 1,
+    id: 'com.example.integerEnum',
+    defs: {
+      main: {
+        type: 'record',
+        record: {
+          type: 'object',
+          properties: {
+            integer: {
+              type: 'integer',
+              enum: [1, 2],
+            },
+          },
+        },
+      },
+    },
+  },
+  {
+    lexicon: 1,
+    id: 'com.example.integerConst',
+    defs: {
+      main: {
+        type: 'record',
+        record: {
+          type: 'object',
+          properties: {
+            integer: {
+              type: 'integer',
+              const: 0,
+            },
+          },
+        },
+      },
+    },
+  },
+  {
+    lexicon: 1,
+    id: 'com.example.stringLength',
+    defs: {
+      main: {
+        type: 'record',
+        record: {
+          type: 'object',
+          properties: {
+            string: {
+              type: 'string',
+              minLength: 2,
+              maxLength: 4,
+            },
+          },
+        },
+      },
+    },
+  },
+  {
+    lexicon: 1,
+    id: 'com.example.stringEnum',
+    defs: {
+      main: {
+        type: 'record',
+        record: {
+          type: 'object',
+          properties: {
+            string: {
+              type: 'string',
+              enum: ['a', 'b'],
+            },
+          },
+        },
+      },
+    },
+  },
+  {
+    lexicon: 1,
+    id: 'com.example.stringConst',
+    defs: {
+      main: {
+        type: 'record',
+        record: {
+          type: 'object',
+          properties: {
+            string: {
+              type: 'string',
+              const: 'a',
+            },
+          },
+        },
+      },
+    },
+  },
+]