@atproto/lex-schema 0.0.1 → 0.0.3

package/dist/validation/validator.js

@@ -1,72 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValidatorContext = exports.Validator = void 0;
+exports.ValidatorContext = void 0;
 const core_js_1 = require("../core.js");
 const validation_error_js_1 = require("./validation-error.js");
-class Validator {
-    /**
-     * This property is used for type inference purposes and does not actually
-     * exist at runtime.
-     *
-     * @deprecated For internal use only (not actually deprecated)
-     */
-    _lex;
-    lexiconType;
-    assert(input) {
-        const result = this.validate(input, { allowTransform: false });
-        if (!result.success)
-            throw result.error;
-    }
-    check(input) {
-        const result = this.validate(input, { allowTransform: false });
-        return result.success;
-    }
-    maybe(input) {
-        return this.check(input) ? input : undefined;
-    }
-    parse(input, options) {
-        const result = ValidatorContext.validate(input, this, options);
-        if (!result.success)
-            throw result.error;
-        return result.value;
-    }
-    validate(input, options) {
-        return ValidatorContext.validate(input, this, options);
-    }
-    // @NOTE The built lexicons namespaces will export utility functions that
-    // allow accessing the schema's methods without the need to specify ".main."
-    // as part of the namespace. This way, a utility for a particular record type
-    // can be called like "app.bsky.feed.post.<utility>()" instead of
-    // "app.bsky.feed.post.main.<utility>()". Because those utilities could
-    // conflict with other schemas (e.g. if there is a lexicon definition at
-    // "#<utility>"), those exported utilities will be prefixed with "$". In order
-    // to be able to consistently call the utilities, when using the "main" and
-    // non "main" definitions, we also expose the same methods with a "$" prefix.
-    // Thanks to this, both of the following call will be possible:
-    //
-    // - "app.bsky.feed.post.$parse(...)" // calls a utility function created by "lex build"
-    // - "app.bsky.feed.defs.postView.$parse(...)" // uses the alias defined below on the schema instance
-    $assert(input) {
-        return this.assert(input);
-    }
-    $check(input) {
-        return this.check(input);
-    }
-    $maybe(input) {
-        return this.maybe(input);
-    }
-    $parse(input, options) {
-        return this.parse(input, options);
-    }
-    $validate(input, options) {
-        return this.validate(input, options);
-    }
-}
-exports.Validator = Validator;
-const asIssue = ({ path, ...issue }, currentPath) => ({
-    ...issue,
-    path: path != null ? currentPath.concat(path) : [...currentPath],
-});
+const validation_issue_js_1 = require("./validation-issue.js");
 class ValidatorContext {
     options;
     /**
@@ -82,14 +19,15 @@ class ValidatorContext {
     constructor(options) {
         this.options = options;
         // Create a copy because we will be mutating the array during validation.
-        this.currentPath = options?.path != null ? [...options.path] : [];
+        this.currentPath = options?.path != null ? Array.from(options.path) : [];
     }
     get path() {
-        return [...this.currentPath];
+        return Array.from(this.currentPath);
     }
-    get allowTransform() {
-        // Default to true
-        return this.options?.allowTransform !== false;
+    concatPath(path) {
+        if (path == null)
+            return this.path;
+        return this.currentPath.concat(path);
     }
     /**
      * This is basically the entry point for validation within a context. Use this
@@ -97,9 +35,13 @@ class ValidatorContext {
      * this method enforces the {@link ValidationOptions.allowTransform} option.
      */
     validate(input, validator) {
+        // This is the only place where validateInContext should be called.
         const result = validator.validateInContext(input, this);
         if (result.success) {
-            if (!this.allowTransform && !Object.is(result.value, input)) {
+            if (
+            // Defaults to true
+            this.options?.allowTransform === false &&
+                !Object.is(result.value, input)) {
                 // If the value changed, it means that a default (or some other
                 // transformation) was applied, meaning that the original value did
                 // *not* match the (output) schema. When "allowTransform" is false, we
@@ -116,7 +58,7 @@ class ValidatorContext {
             if (this.issues.length > 0) {
                 // Validator returned a success but issues were added via the context.
                 // This means the overall validation failed.
-                return { success: false, error: new validation_error_js_1.ValidationError(this.issues) };
+                return (0, core_js_1.failure)(new validation_error_js_1.ValidationError(Array.from(this.issues)));
             }
         }
         return result;
@@ -132,77 +74,41 @@ class ValidatorContext {
         }
     }
     addIssue(issue) {
-        this.issues.push(asIssue(issue, this.currentPath));
+        this.issues.push(issue);
     }
     success(value) {
         return (0, core_js_1.success)(value);
     }
     failure(issue) {
-        return (0, core_js_1.failure)(new validation_error_js_1.ValidationError([...this.issues, asIssue(issue, this.currentPath)]));
-    }
-    issueInvalidValue(input, values, path) {
-        return this.failure({
-            code: 'invalid_value',
-            input,
-            values,
-            path,
-        });
-    }
-    issueInvalidType(input, expected, path) {
-        return this.failure({
-            code: 'invalid_type',
-            input,
-            expected: Array.isArray(expected) ? expected : [expected],
-            path,
-        });
+        return (0, core_js_1.failure)(new validation_error_js_1.ValidationError([...this.issues, issue]));
     }
-    issueInvalidPropertyValue(input, property, values) {
-        return this.issueInvalidValue(input[property], values, property);
+    issueInvalidValue(input, values) {
+        return this.failure(new validation_issue_js_1.IssueInvalidValue(this.path, input, values));
     }
-    issueInvalidPropertyType(input, property, expected) {
-        return this.issueInvalidType(input[property], expected, property);
+    issueInvalidType(input, expected) {
+        return this.failure(new validation_issue_js_1.IssueInvalidType(this.path, input, [expected]));
     }
     issueRequiredKey(input, key) {
-        return this.failure({
-            code: 'required_key',
-            key,
-            input,
-            path: key,
-        });
-    }
-    issueInvalidFormat(input, format, message) {
-        return this.failure({
-            code: 'invalid_format',
-            message,
-            format,
-            input,
-        });
-    }
-    issueTooBig(input, type, maximum, actual) {
-        return this.failure({
-            code: 'too_big',
-            type,
-            maximum,
-            actual,
-            input,
-        });
-    }
-    issueTooSmall(input, type, minimum, actual) {
-        return this.failure({
-            code: 'too_small',
-            type,
-            minimum,
-            actual,
-            input,
-        });
-    }
-    custom(input, message, path) {
-        return this.failure({
-            code: 'custom',
-            input,
-            message,
-            path,
-        });
+        return this.failure(new validation_issue_js_1.IssueRequiredKey(this.path, input, key));
+    }
+    issueInvalidFormat(input, format, msg) {
+        return this.failure(new validation_issue_js_1.IssueInvalidFormat(this.path, input, format, msg));
+    }
+    issueTooBig(input, type, max, actual) {
+        return this.failure(new validation_issue_js_1.IssueTooBig(this.path, input, max, type, actual));
+    }
+    issueTooSmall(input, type, min, actual) {
+        return this.failure(new validation_issue_js_1.IssueTooSmall(this.path, input, min, type, actual));
+    }
+    issueInvalidPropertyValue(input, property, values) {
+        const value = input[property];
+        const path = this.concatPath(property);
+        return this.failure(new validation_issue_js_1.IssueInvalidValue(path, value, values));
+    }
+    issueInvalidPropertyType(input, property, expected) {
+        const value = input[property];
+        const path = this.concatPath(property);
+        return this.failure(new validation_issue_js_1.IssueInvalidType(path, value, [expected]));
     }
 }
 exports.ValidatorContext = ValidatorContext;

package/dist/validation/validator.js.map

@@ -1 +1 @@
-{"version":3,"file":"validator.js","sourceRoot":"","sources":["../../src/validation/validator.ts"],"names":[],"mappings":"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","sourcesContent":["import { ResultFailure, ResultSuccess, failure, success } from '../core.js'\nimport { PropertyKey } from './property-key.js'\nimport { ValidationError } from './validation-error.js'\nimport {\n  IssueTooBig,\n  IssueTooSmall,\n  ValidationIssue,\n} from './validation-issue.js'\n\nexport type ValidationSuccess<Value = any> = ResultSuccess<Value>\nexport type ValidationFailure = ResultFailure<ValidationError>\nexport type ValidationResult<Value = any> =\n  | ValidationSuccess<Value>\n  | ValidationFailure\n\ntype ValidationOptions = {\n  path?: PropertyKey[]\n\n  /** @default true */\n  allowTransform?: boolean\n}\n\nexport type Infer<T extends Validator> = T['_lex']['output']\n\nexport abstract class Validator<Output = any> {\n  /**\n   * This property is used for type inference purposes and does not actually\n   * exist at runtime.\n   *\n   * @deprecated For internal use only (not actually deprecated)\n   */\n  _lex!: { output: Output }\n\n  readonly lexiconType?: string\n\n  /**\n   * @internal **INTERNAL API, DO NOT USE**.\n   *\n   * Use {@link Validator.assert assert}, {@link Validator.check check},\n   * {@link Validator.parse parse} or {@link Validator.validate validate}\n   * instead.\n   *\n   * This method is implemented by subclasses to perform transformation and\n   * validation of the input value. Do not call this method directly; as the\n   * {@link ValidatorContext.options.allowTransform} option will **not** be\n   * enforced. See {@link ValidatorContext.validate} for details. When\n   * delegating validation from one validator sub-class implementation to\n   * another schema, {@link ValidatorContext.validate} should be used instead\n   * of calling {@link Validator.validateInContext}. This will allow to stop the\n   * validation process if the value was transformed (by the other schema) but\n   * transformations are not allowed.\n   *\n   * By convention, the {@link ValidationResult} must return the original input\n   * value if validation was successful and no transformation was applied (i.e.\n   * the input already conformed to the schema). If a default value, or any\n   * other transformation was applied, the returned value c&an be different from\n   * the input.\n   *\n   * This convention allows the {@link Validator.check check} and\n   * {@link Validator.assert assert} methods to check whether the input value\n   * exactly matches the schema (without defaults or transformations), by\n   * checking if the returned value is strictly equal to the input.\n   *\n   * @see {@link ValidatorContext.validate}\n   */\n  abstract validateInContext(\n    input: unknown,\n    ctx: ValidatorContext,\n  ): ValidationResult<Output>\n\n  assert(input: unknown): asserts input is Output {\n    const result = this.validate(input, { allowTransform: false })\n    if (!result.success) throw result.error\n  }\n\n  check(input: unknown): input is Output {\n    const result = this.validate(input, { allowTransform: false })\n    return result.success\n  }\n\n  maybe<I>(input: I): (I & Output) | undefined {\n    return this.check(input) ? input : undefined\n  }\n\n  parse<I>(\n    input: I,\n    options: ValidationOptions & { allowTransform: false },\n  ): I & Output\n  parse(input: unknown, options?: ValidationOptions): Output\n  parse(input: unknown, options?: ValidationOptions): Output {\n    const result = ValidatorContext.validate(input, this, options)\n    if (!result.success) throw result.error\n    return result.value\n  }\n\n  validate<I>(\n    input: I,\n    options: ValidationOptions & { allowTransform: false },\n  ): ValidationResult<I & Output>\n  validate(\n    input: unknown,\n    options?: ValidationOptions,\n  ): ValidationResult<Output>\n  validate(\n    input: unknown,\n    options?: ValidationOptions,\n  ): ValidationResult<Output> {\n    return ValidatorContext.validate(input, this, options)\n  }\n\n  // @NOTE The built lexicons namespaces will export utility functions that\n  // allow accessing the schema's methods without the need to specify \".main.\"\n  // as part of the namespace. This way, a utility for a particular record type\n  // can be called like \"app.bsky.feed.post.<utility>()\" instead of\n  // \"app.bsky.feed.post.main.<utility>()\". Because those utilities could\n  // conflict with other schemas (e.g. if there is a lexicon definition at\n  // \"#<utility>\"), those exported utilities will be prefixed with \"$\". In order\n  // to be able to consistently call the utilities, when using the \"main\" and\n  // non \"main\" definitions, we also expose the same methods with a \"$\" prefix.\n  // Thanks to this, both of the following call will be possible:\n  //\n  // - \"app.bsky.feed.post.$parse(...)\" // calls a utility function created by \"lex build\"\n  // - \"app.bsky.feed.defs.postView.$parse(...)\" // uses the alias defined below on the schema instance\n\n  $assert(input: unknown): asserts input is Output {\n    return this.assert(input)\n  }\n\n  $check(input: unknown): input is Output {\n    return this.check(input)\n  }\n\n  $maybe<I>(input: I): (I & Output) | undefined {\n    return this.maybe(input)\n  }\n\n  $parse(input: unknown, options?: ValidationOptions): Output {\n    return this.parse(input, options)\n  }\n\n  $validate(\n    input: unknown,\n    options?: ValidationOptions,\n  ): ValidationResult<Output> {\n    return this.validate(input, options)\n  }\n}\n\nexport type ContextualIssue = {\n  [Code in ValidationIssue['code']]: Omit<\n    Extract<ValidationIssue, { code: Code }>,\n    'path'\n  > & { path?: PropertyKey | readonly PropertyKey[] }\n}[ValidationIssue['code']]\n\nconst asIssue = (\n  { path, ...issue }: ContextualIssue,\n  currentPath: readonly PropertyKey[],\n): ValidationIssue & { path: PropertyKey[] } => ({\n  ...issue,\n  path: path != null ? currentPath.concat(path) : [...currentPath],\n})\n\nexport class ValidatorContext {\n  /**\n   * Creates a new validation context and validates the input using the\n   * provided validator.\n   */\n  static validate<V>(\n    input: unknown,\n    validator: Validator<V>,\n    options: ValidationOptions = {},\n  ): ValidationResult<V> {\n    const context = new ValidatorContext(options)\n    return context.validate(input, validator)\n  }\n\n  private readonly currentPath: PropertyKey[]\n  private readonly issues: ValidationIssue[] = []\n\n  protected constructor(readonly options: ValidationOptions) {\n    // Create a copy because we will be mutating the array during validation.\n    this.currentPath = options?.path != null ? [...options.path] : []\n  }\n\n  get path() {\n    return [...this.currentPath]\n  }\n\n  get allowTransform() {\n    // Default to true\n    return this.options?.allowTransform !== false\n  }\n\n  /**\n   * This is basically the entry point for validation within a context. Use this\n   * method instead of {@link Validator.validateInContext} directly, because\n   * this method enforces the {@link ValidationOptions.allowTransform} option.\n   */\n  validate<V>(input: unknown, validator: Validator<V>): ValidationResult<V> {\n    const result = validator.validateInContext(input, this)\n\n    if (result.success) {\n      if (!this.allowTransform && !Object.is(result.value, input)) {\n        // If the value changed, it means that a default (or some other\n        // transformation) was applied, meaning that the original value did\n        // *not* match the (output) schema. When \"allowTransform\" is false, we\n        // consider this a failure.\n\n        // This check is the reason why Validator.validateInContext should not\n        // be used directly, and ValidatorContext.validate should be used\n        // instead, even when delegating validation from one validator to\n        // another.\n\n        // This if block comes before the next one because 'this.issues' will\n        // end-up being appended to the returned ValidationError (see the\n        // \"failure\" method below), resulting in a more complete error report.\n        return this.issueInvalidValue(input, [result.value])\n      }\n\n      if (this.issues.length > 0) {\n        // Validator returned a success but issues were added via the context.\n        // This means the overall validation failed.\n        return { success: false, error: new ValidationError(this.issues) }\n      }\n    }\n\n    return result\n  }\n\n  validateChild<I extends object, K extends PropertyKey & keyof I, V>(\n    input: I,\n    key: K,\n    validator: Validator<V>,\n  ): ValidationResult<V> {\n    // Instead of creating a new context, we just push/pop the path segment.\n    this.currentPath.push(key)\n    try {\n      return this.validate(input[key], validator)\n    } finally {\n      this.currentPath.length--\n    }\n  }\n\n  addIssue(issue: ContextualIssue): void {\n    this.issues.push(asIssue(issue, this.currentPath))\n  }\n\n  success<V>(value: V): ValidationResult<V> {\n    return success(value)\n  }\n\n  failure(issue: ContextualIssue): ValidationFailure {\n    return failure(\n      new ValidationError([...this.issues, asIssue(issue, this.currentPath)]),\n    )\n  }\n\n  issueInvalidValue(\n    input: unknown,\n    values: readonly unknown[],\n    path?: PropertyKey | readonly PropertyKey[],\n  ) {\n    return this.failure({\n      code: 'invalid_value',\n      input,\n      values,\n      path,\n    })\n  }\n\n  issueInvalidType(\n    input: unknown,\n    expected: string | readonly string[],\n    path?: PropertyKey | readonly PropertyKey[],\n  ) {\n    return this.failure({\n      code: 'invalid_type',\n      input,\n      expected: Array.isArray(expected) ? expected : [expected],\n      path,\n    })\n  }\n\n  issueInvalidPropertyValue<I>(\n    input: I,\n    property: keyof I & PropertyKey,\n    values: readonly unknown[],\n  ) {\n    return this.issueInvalidValue(input[property], values, property)\n  }\n\n  issueInvalidPropertyType<I>(\n    input: I,\n    property: keyof I & PropertyKey,\n    expected: string | readonly string[],\n  ) {\n    return this.issueInvalidType(input[property], expected, property)\n  }\n\n  issueRequiredKey(input: object, key: PropertyKey) {\n    return this.failure({\n      code: 'required_key',\n      key,\n      input,\n      path: key,\n    })\n  }\n\n  issueInvalidFormat(input: unknown, format: string, message?: string) {\n    return this.failure({\n      code: 'invalid_format',\n      message,\n      format,\n      input,\n    })\n  }\n\n  issueTooBig(\n    input: unknown,\n    type: IssueTooBig['type'],\n    maximum: number,\n    actual: number,\n  ) {\n    return this.failure({\n      code: 'too_big',\n      type,\n      maximum,\n      actual,\n      input,\n    })\n  }\n\n  issueTooSmall(\n    input: unknown,\n    type: IssueTooSmall['type'],\n    minimum: number,\n    actual: number,\n  ) {\n    return this.failure({\n      code: 'too_small',\n      type,\n      minimum,\n      actual,\n      input,\n    })\n  }\n\n  custom(\n    input: unknown,\n    message: string,\n    path?: PropertyKey | readonly PropertyKey[],\n  ) {\n    return this.failure({\n      code: 'custom',\n      input,\n      message,\n      path,\n    })\n  }\n}\n"]}
+{"version":3,"file":"validator.js","sourceRoot":"","sources":["../../src/validation/validator.ts"],"names":[],"mappings":"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","sourcesContent":["import { ResultFailure, ResultSuccess, failure, success } from '../core.js'\nimport { PropertyKey } from './property-key.js'\nimport { ValidationError } from './validation-error.js'\nimport {\n  Issue,\n  IssueInvalidFormat,\n  IssueInvalidType,\n  IssueInvalidValue,\n  IssueRequiredKey,\n  IssueTooBig,\n  IssueTooSmall,\n  MeasurableType,\n} from './validation-issue.js'\n\nexport type ValidationSuccess<Value = any> = ResultSuccess<Value>\nexport type ValidationFailure = ResultFailure<ValidationError>\nexport type ValidationResult<Value = any> =\n  | ValidationSuccess<Value>\n  | ValidationFailure\n\nexport type ValidationOptions = {\n  path?: PropertyKey[]\n\n  /** @default true */\n  allowTransform?: boolean\n}\n\nexport type Infer<T extends Validator> = T['_lex']['output']\n\nexport interface Validator<Output = any> {\n  /**\n   * This property is used for type inference purposes and does not actually\n   * exist at runtime.\n   *\n   * @deprecated **INTERNAL API, DO NOT USE**.\n   */\n  readonly ['_lex']: { output: Output }\n\n  /**\n   * @internal **INTERNAL API**: use {@link ValidatorContext.validate} instead\n   *\n   * This method is implemented by subclasses to perform transformation and\n   * validation of the input value. Do not call this method directly; as the\n   * {@link ValidatorContext.options.allowTransform} option will **not** be\n   * enforced. See {@link ValidatorContext.validate} for details. When\n   * delegating validation from one validator sub-class implementation to\n   * another schema, {@link ValidatorContext.validate} must be used instead of\n   * calling {@link Validator.validateInContext}. This will allow to stop the\n   * validation process if the value was transformed (by the other schema) but\n   * transformations are not allowed.\n   *\n   * By convention, the {@link ValidationResult} must return the original input\n   * value if validation was successful and no transformation was applied (i.e.\n   * the input already conformed to the schema). If a default value, or any\n   * other transformation was applied, the returned value c&an be different from\n   * the input.\n   *\n   * This convention allows the {@link Validator.check check} and\n   * {@link Validator.assert assert} methods to check whether the input value\n   * exactly matches the schema (without defaults or transformations), by\n   * checking if the returned value is strictly equal to the input.\n   *\n   * @see {@link ValidatorContext.validate}\n   */\n  validateInContext(\n    input: unknown,\n    ctx: ValidatorContext,\n  ): ValidationResult<Output>\n}\n\nexport class ValidatorContext {\n  /**\n   * Creates a new validation context and validates the input using the\n   * provided validator.\n   */\n  static validate<V>(\n    input: unknown,\n    validator: Validator<V>,\n    options: ValidationOptions = {},\n  ): ValidationResult<V> {\n    const context = new ValidatorContext(options)\n    return context.validate(input, validator)\n  }\n\n  private readonly currentPath: PropertyKey[]\n  private readonly issues: Issue[] = []\n\n  protected constructor(readonly options: ValidationOptions) {\n    // Create a copy because we will be mutating the array during validation.\n    this.currentPath = options?.path != null ? Array.from(options.path) : []\n  }\n\n  get path() {\n    return Array.from(this.currentPath)\n  }\n\n  concatPath(path?: PropertyKey | readonly PropertyKey[]) {\n    if (path == null) return this.path\n    return this.currentPath.concat(path)\n  }\n\n  /**\n   * This is basically the entry point for validation within a context. Use this\n   * method instead of {@link Validator.validateInContext} directly, because\n   * this method enforces the {@link ValidationOptions.allowTransform} option.\n   */\n  validate<V>(input: unknown, validator: Validator<V>): ValidationResult<V> {\n    // This is the only place where validateInContext should be called.\n    const result = validator.validateInContext(input, this)\n\n    if (result.success) {\n      if (\n        // Defaults to true\n        this.options?.allowTransform === false &&\n        !Object.is(result.value, input)\n      ) {\n        // If the value changed, it means that a default (or some other\n        // transformation) was applied, meaning that the original value did\n        // *not* match the (output) schema. When \"allowTransform\" is false, we\n        // consider this a failure.\n\n        // This check is the reason why Validator.validateInContext should not\n        // be used directly, and ValidatorContext.validate should be used\n        // instead, even when delegating validation from one validator to\n        // another.\n\n        // This if block comes before the next one because 'this.issues' will\n        // end-up being appended to the returned ValidationError (see the\n        // \"failure\" method below), resulting in a more complete error report.\n        return this.issueInvalidValue(input, [result.value])\n      }\n\n      if (this.issues.length > 0) {\n        // Validator returned a success but issues were added via the context.\n        // This means the overall validation failed.\n        return failure(new ValidationError(Array.from(this.issues)))\n      }\n    }\n\n    return result as ValidationResult<V>\n  }\n\n  validateChild<\n    I extends object,\n    K extends PropertyKey & keyof I,\n    V extends Validator,\n  >(input: I, key: K, validator: V): ValidationResult<Infer<V>> {\n    // Instead of creating a new context, we just push/pop the path segment.\n    this.currentPath.push(key)\n    try {\n      return this.validate(input[key], validator)\n    } finally {\n      this.currentPath.length--\n    }\n  }\n\n  addIssue(issue: Issue): void {\n    this.issues.push(issue)\n  }\n\n  success<V>(value: V): ValidationResult<V> {\n    return success(value)\n  }\n\n  failure(issue: Issue): ValidationFailure {\n    return failure(new ValidationError([...this.issues, issue]))\n  }\n\n  issueInvalidValue(input: unknown, values: readonly unknown[]) {\n    return this.failure(new IssueInvalidValue(this.path, input, values))\n  }\n\n  issueInvalidType(input: unknown, expected: string) {\n    return this.failure(new IssueInvalidType(this.path, input, [expected]))\n  }\n\n  issueRequiredKey(input: object, key: PropertyKey) {\n    return this.failure(new IssueRequiredKey(this.path, input, key))\n  }\n\n  issueInvalidFormat(input: unknown, format: string, msg?: string) {\n    return this.failure(new IssueInvalidFormat(this.path, input, format, msg))\n  }\n\n  issueTooBig(\n    input: unknown,\n    type: MeasurableType,\n    max: number,\n    actual: number,\n  ) {\n    return this.failure(new IssueTooBig(this.path, input, max, type, actual))\n  }\n\n  issueTooSmall(\n    input: unknown,\n    type: MeasurableType,\n    min: number,\n    actual: number,\n  ) {\n    return this.failure(new IssueTooSmall(this.path, input, min, type, actual))\n  }\n\n  issueInvalidPropertyValue<I>(\n    input: I,\n    property: keyof I & PropertyKey,\n    values: readonly unknown[],\n  ) {\n    const value = input[property]\n    const path = this.concatPath(property)\n    return this.failure(new IssueInvalidValue(path, value, values))\n  }\n\n  issueInvalidPropertyType<I>(\n    input: I,\n    property: keyof I & PropertyKey,\n    expected: string,\n  ) {\n    const value = input[property]\n    const path = this.concatPath(property)\n    return this.failure(new IssueInvalidType(path, value, [expected]))\n  }\n}\n"]}

package/dist/validation.d.ts

@@ -1,4 +1,5 @@
 export * from './validation/property-key.js';
+export * from './validation/schema.js';
 export * from './validation/validation-error.js';
 export * from './validation/validation-issue.js';
 export * from './validation/validator.js';

package/dist/validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAA;AAC5C,cAAc,kCAAkC,CAAA;AAChD,cAAc,kCAAkC,CAAA;AAChD,cAAc,2BAA2B,CAAA"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAA;AAC5C,cAAc,wBAAwB,CAAA;AACtC,cAAc,kCAAkC,CAAA;AAChD,cAAc,kCAAkC,CAAA;AAChD,cAAc,2BAA2B,CAAA"}

package/dist/validation.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./validation/property-key.js"), exports);
+tslib_1.__exportStar(require("./validation/schema.js"), exports);
 tslib_1.__exportStar(require("./validation/validation-error.js"), exports);
 tslib_1.__exportStar(require("./validation/validation-issue.js"), exports);
 tslib_1.__exportStar(require("./validation/validator.js"), exports);

package/dist/validation.js.map

@@ -1 +1 @@
-{"version":3,"file":"validation.js","sourceRoot":"","sources":["../src/validation.ts"],"names":[],"mappings":";;;AAAA,uEAA4C;AAC5C,2EAAgD;AAChD,2EAAgD;AAChD,oEAAyC","sourcesContent":["export * from './validation/property-key.js'\nexport * from './validation/validation-error.js'\nexport * from './validation/validation-issue.js'\nexport * from './validation/validator.js'\n"]}
+{"version":3,"file":"validation.js","sourceRoot":"","sources":["../src/validation.ts"],"names":[],"mappings":";;;AAAA,uEAA4C;AAC5C,iEAAsC;AACtC,2EAAgD;AAChD,2EAAgD;AAChD,oEAAyC","sourcesContent":["export * from './validation/property-key.js'\nexport * from './validation/schema.js'\nexport * from './validation/validation-error.js'\nexport * from './validation/validation-issue.js'\nexport * from './validation/validator.js'\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atproto/lex-schema",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "license": "MIT",
   "description": "Lexicon schema system for AT Lexicons",
   "keywords": [
@@ -16,7 +16,11 @@
   },
   "files": [
     "./src",
-    "./dist"
+    "./tsconfig.build.json",
+    "./tsconfig.tests.json",
+    "./tsconfig.json",
+    "./dist",
+    "./CHANGELOG.md"
   ],
   "sideEffects": false,
   "type": "commonjs",
@@ -32,8 +36,8 @@
   },
   "dependencies": {
     "tslib": "^2.8.1",
-    "@atproto/syntax": "0.4.1",
-    "@atproto/lex-data": "0.0.1"
+    "@atproto/syntax": "0.4.2",
+    "@atproto/lex-data": "0.0.2"
   },
   "devDependencies": {
     "jest": "^28.1.2"

package/src/core/$type.ts

@@ -1,9 +1,9 @@
-import { Nsid } from './string-format.js'
+import { NsidString } from './string-format.js'
 
 export type $Type<
-  N extends Nsid = Nsid,
+  N extends NsidString = NsidString,
   H extends string = string,
-> = N extends Nsid
+> = N extends NsidString
   ? string extends H
     ? N | `${N}#${string}`
     : H extends 'main'
@@ -11,7 +11,10 @@ export type $Type<
       : `${N}#${H}`
   : never
 
-export function $type<N extends Nsid, H extends string>(
+export type $TypeOf<O extends { $type?: string }> = NonNullable<O['$type']>
+
+/*@__NO_SIDE_EFFECTS__*/
+export function $type<N extends NsidString, H extends string>(
   nsid: N,
   hash: H,
 ): $Type<N, H> {

package/src/core/record-key.ts

@@ -1,15 +1,22 @@
-export type RecordKey = 'any' | 'nsid' | 'tid' | `literal:${string}`
+import { isValidRecordKey } from '@atproto/syntax'
 
-export function isRecordKey<T>(key: T): key is T & RecordKey {
+export type LexiconRecordKey = 'any' | 'nsid' | 'tid' | `literal:${string}`
+
+/*@__NO_SIDE_EFFECTS__*/
+export function isLexiconRecordKey<T>(key: T): key is T & LexiconRecordKey {
   return (
     key === 'any' ||
     key === 'nsid' ||
     key === 'tid' ||
-    (typeof key === 'string' && key.startsWith('literal:'))
+    (typeof key === 'string' &&
+      key.startsWith('literal:') &&
+      key.length > 8 &&
+      isValidRecordKey(key.slice(8)))
   )
 }
 
-export function asRecordKey(key: unknown): RecordKey {
-  if (isRecordKey(key)) return key
+/*@__NO_SIDE_EFFECTS__*/
+export function asLexiconRecordKey(key: unknown): LexiconRecordKey {
+  if (isLexiconRecordKey(key)) return key
   throw new Error(`Invalid record key: ${String(key)}`)
 }

package/src/core/result.ts

@@ -3,18 +3,22 @@ export type ResultFailure<E = Error> = { success: false; error: E }
 
 export type Result<V = any, E = Error> = ResultSuccess<V> | ResultFailure<E>
 
+/*@__NO_SIDE_EFFECTS__*/
 export function success<V>(value: V): ResultSuccess<V> {
   return { success: true, value }
 }
 
+/*@__NO_SIDE_EFFECTS__*/
 export function failure<E>(error: E): ResultFailure<E> {
   return { success: false, error }
 }
 
+/*@__NO_SIDE_EFFECTS__*/
 export function failureError<T>(result: ResultFailure<T>): T {
   return result.error
 }
 
+/*@__NO_SIDE_EFFECTS__*/
 export function successValue<T>(result: ResultSuccess<T>): T {
   return result.value
 }
@@ -38,6 +42,7 @@ export function successValue<T>(result: ResultSuccess<T>): T {
  * }
  * ```
  */
+/*@__NO_SIDE_EFFECTS__*/
 export function catchall(err: unknown): ResultFailure<Error> {
   if (err instanceof Error) return failure(err)
   return failure(new Error('Unknown error', { cause: err }))
@@ -65,6 +70,7 @@ export function catchall(err: unknown): ResultFailure<Error> {
  *   console.error(result.error) // FooError | BarError
  * }
  */
+/*@__NO_SIDE_EFFECTS__*/
 export function createCatcher<T>(Ctor: new (...args: any[]) => T) {
   return (err: unknown): ResultFailure<T> => {
     if (err instanceof Ctor) return failure(err)

package/src/core/string-format.ts

@@ -1,5 +1,14 @@
 import { ensureValidCidString, isLanguage } from '@atproto/lex-data'
 import {
+  AtIdentifierString,
+  AtUriString,
+  DatetimeString,
+  DidString,
+  HandleString,
+  NsidString,
+  RecordKeyString,
+  TidString,
+  ensureValidAtIdentifier,
   ensureValidAtUri,
   ensureValidDatetime,
   ensureValidDid,
@@ -9,13 +18,87 @@ import {
   ensureValidTid,
 } from '@atproto/syntax'
 
-// Allow (date as Date).toISOString() to be used where datetime format is expected
-declare global {
-  interface Date {
-    toISOString(): `${string}T${string}Z`
+type AssertFn<T> = <I extends string>(input: I) => asserts input is I & T
+type CastFn<T> = <I extends string>(input: I) => I & T
+
+/*@__NO_SIDE_EFFECTS__*/
+function createCastFunction<T>(assertFn: AssertFn<T>): CastFn<T> {
+  return <I extends string>(input: I) => {
+    assertFn(input)
+    return input as I & T
   }
 }
 
+// Re-export utility typed as assertion functions so that TypeScript can
+// infer the narrowed type after calling them.
+
+export type {
+  AtIdentifierString,
+  AtUriString,
+  DatetimeString,
+  DidString,
+  HandleString,
+  NsidString,
+  RecordKeyString,
+  TidString,
+}
+
+export const assertDid: AssertFn<DidString> = ensureValidDid
+export const assertAtUri: AssertFn<AtUriString> = ensureValidAtUri
+export const assertAtIdentifier: AssertFn<AtIdentifierString> =
+  ensureValidAtIdentifier
+export const assertNsid: AssertFn<NsidString> = ensureValidNsid
+export const assertTid: AssertFn<TidString> = ensureValidTid
+export const assertRecordKey: AssertFn<RecordKeyString> = ensureValidRecordKey
+export const assertDatetime: AssertFn<DatetimeString> = ensureValidDatetime
+export const assertCidString: AssertFn<string> = ensureValidCidString
+export const assertHandle: AssertFn<HandleString> = ensureValidHandle
+
+// Export utilities for formats missing from @atproto/syntax
+
+export type CidString = string
+export type UriString = `${string}:${string}`
+export type LanguageString = string
+
+/*@__NO_SIDE_EFFECTS__*/
+export function assertUri(input: string): asserts input is UriString {
+  if (!/^\w+:(?:\/\/)?[^\s/][^\s]*$/.test(input)) {
+    throw new Error('Invalid URI')
+  }
+}
+
+/*@__NO_SIDE_EFFECTS__*/
+export function assertLanguage(input: string): asserts input is LanguageString {
+  if (!isLanguage(input)) {
+    throw new Error('Invalid BCP 47 string')
+  }
+}
+
+export const asDid: CastFn<DidString> =
+  /*#__PURE__*/ createCastFunction(ensureValidDid)
+export const asAtUri: CastFn<AtUriString> =
+  /*#__PURE__*/ createCastFunction(ensureValidAtUri)
+export const asNsid: CastFn<NsidString> =
+  /*#__PURE__*/ createCastFunction(ensureValidNsid)
+export const asTid: CastFn<TidString> =
+  /*#__PURE__*/ createCastFunction(ensureValidTid)
+export const asRecordKey: CastFn<RecordKeyString> =
+  /*#__PURE__*/ createCastFunction(ensureValidRecordKey)
+export const asDatetime: CastFn<DatetimeString> =
+  /*#__PURE__*/ createCastFunction(ensureValidDatetime)
+export const asCidString: CastFn<string> =
+  /*#__PURE__*/ createCastFunction(ensureValidCidString)
+export const asHandle: CastFn<HandleString> =
+  /*#__PURE__*/ createCastFunction(ensureValidHandle)
+export const asUri: CastFn<UriString> =
+  /*#__PURE__*/ createCastFunction(assertUri)
+export const asLanguage: CastFn<LanguageString> =
+  /*#__PURE__*/ createCastFunction(assertLanguage)
+export const asAtIdentifier: CastFn<AtIdentifierString> =
+  /*#__PURE__*/ createCastFunction(assertAtIdentifier)
+
+// String formatting types and utilities
+
 export const STRING_FORMATS = Object.freeze([
   'datetime',
   'uri',
@@ -32,72 +115,24 @@ export const STRING_FORMATS = Object.freeze([
 
 export type StringFormat = (typeof STRING_FORMATS)[number]
 
-export type Did<M extends string = string> = `did:${M}:${string}`
-export type Uri = `${string}:${string}`
-export type Nsid = `${string}.${string}.${string}`
-/** An ISO 8601 formatted datetime string (YYYY-MM-DDTHH:mm:ss.sssZ) */
-export type Datetime = `${string}T${string}`
-export type Handle = `${string}.${string}`
-export type AtIdentifier = Did | Handle
-export type AtUri = `at://${AtIdentifier}/${Nsid}/${string}`
-
 export type InferStringFormat<F> =
   //
   F extends 'datetime'
-    ? Datetime
+    ? DatetimeString
     : F extends 'uri'
-      ? Uri
+      ? UriString
       : F extends 'at-uri'
-        ? AtUri
+        ? AtUriString
         : F extends 'did'
-          ? Did
+          ? DidString
           : F extends 'handle'
-            ? Handle
+            ? HandleString
             : F extends 'at-identifier'
-              ? AtIdentifier
+              ? AtIdentifierString
               : F extends 'nsid'
-                ? Nsid
-                : string
-
-type AssertFn<T> = <I extends string>(input: I) => asserts input is I & T
-
-// Re-export utility typed as assertion functions so that TypeScript can
-// infer the narrowed type after calling them.
-
-export const assertDid: AssertFn<Did> = ensureValidDid
-export const assertAtUri: AssertFn<AtUri> = ensureValidAtUri
-export const assertNsid: AssertFn<Nsid> = ensureValidNsid
-export const assertTid: AssertFn<string> = ensureValidTid
-export const assertRecordKey: AssertFn<string> = ensureValidRecordKey
-export const assertDatetime: AssertFn<Datetime> = ensureValidDatetime
-export const assertCidString: AssertFn<string> = ensureValidCidString
-export const assertHandle: AssertFn<Handle> = ensureValidHandle
-
-// Export utilities for formats missing from @atproto/syntax
-
-export const assertUri: AssertFn<Uri> = (input) => {
-  if (!/^\w+:(?:\/\/)?[^\s/][^\s]*$/.test(input)) {
-    throw new Error('Invalid URI')
-  }
-}
-export const assertLanguage: AssertFn<string> = (input) => {
-  if (!isLanguage(input)) {
-    throw new Error('Invalid BCP 47 string')
-  }
-}
-export const assertAtIdentifier: AssertFn<AtIdentifier> = (input) => {
-  if (input.startsWith('did:web:') || input.startsWith('did:plc:')) {
-    assertDid(input)
-  } else if (input.startsWith('did:')) {
-    throw new Error('Invalid DID method')
-  } else {
-    try {
-      assertHandle(input)
-    } catch (cause) {
-      throw new Error('Invalid DID or handle', { cause })
-    }
-  }
-}
+                ? NsidString
+                : // LanguageString | CidString | TidString | RecordKeyString
+                  string
 
 const formatters = /*#__PURE__*/ new Map<StringFormat, (str: string) => void>([
   ['datetime', assertDatetime],
@@ -113,6 +148,7 @@ const formatters = /*#__PURE__*/ new Map<StringFormat, (str: string) => void>([
   ['record-key', assertRecordKey],
 ] as const)
 
+/*@__NO_SIDE_EFFECTS__*/
 export function assertStringFormat<F extends StringFormat>(
   input: string,
   format: F,