@atproto/lexicon 0.0.1

package/README.md

@@ -0,0 +1,31 @@
+# Lexicon
+
+Lexicon is the semantic schemas & contracts system for ATP. This library provides definitions and APIs for ATP software.
+
+```
+npm install @atproto/lexicon
+```
+
+## Usage
+
+```typescript
+import { Lexicons } from '@atproto/lexicon'
+
+// create your lexicons collection
+const lex = new Lexicons()
+
+// add lexicon documents
+lex.add({
+  lex: 1,
+  id: 'com.example.post',
+  defs: {
+    // ...
+  }
+})
+
+// validate
+lex.assertValidRecord('com.example.record', {$type: 'com.example.record', ...})
+lex.assertValidXrpcParams('com.example.query', {...})
+lex.assertValidXrpcInput('com.example.procedure', {...})
+lex.assertValidXrpcOutput('com.example.query', {...})
+```

package/build.js

@@ -0,0 +1,22 @@
+const pkgJson = require('@npmcli/package-json')
+const { nodeExternalsPlugin } = require('esbuild-node-externals')
+
+const buildShallow =
+  process.argv.includes('--shallow') || process.env.ATP_BUILD_SHALLOW === 'true'
+
+if (process.argv.includes('--update-main-to-dist')) {
+  return pkgJson
+    .load(__dirname)
+    .then((pkg) => pkg.update({ main: 'dist/index.js' }))
+    .then((pkg) => pkg.save())
+}
+
+require('esbuild').build({
+  logLevel: 'info',
+  entryPoints: ['src/index.ts'],
+  bundle: true,
+  sourcemap: true,
+  outdir: 'dist',
+  platform: 'node',
+  plugins: buildShallow ? [nodeExternalsPlugin()] : [],
+})

package/dist/index.d.ts

@@ -0,0 +1,126 @@
+import { ValidateFunction } from 'ajv';
+import { AdxSchemaDefinition } from './types.js';
+declare type SomeObject = Record<string, unknown>;
+export interface AdxRecordValidatorDescription {
+    type: string | string[];
+    ext?: string | string[];
+}
+export * from './types.js';
+/**
+ * A compiled schema.
+ */
+export declare class AdxSchema {
+    def: AdxSchemaDefinition;
+    id: string;
+    validateRecord?: ValidateFunction;
+    validateParams?: ValidateFunction;
+    validateResponse?: ValidateFunction;
+    get name(): string;
+    constructor(def: AdxSchemaDefinition);
+}
+/**
+ * A collection of compiled schemas.
+ */
+export declare class AdxSchemas {
+    schemas: Map<string, AdxSchema>;
+    private _locale;
+    get locale(): string;
+    set locale(v: string);
+    /**
+     * Add a schema definition.
+     */
+    add(schemaDef: unknown): void;
+    /**
+     * Remove a schema definition.
+     */
+    remove(key: string): void;
+    /**
+     * Get a schema definition.
+     */
+    get(key: string): AdxSchema | undefined;
+    /**
+     * Create a record validator out of one or more schemas.
+     */
+    createRecordValidator(desc: string | string[] | AdxRecordValidatorDescription): AdxRecordValidator;
+    /**
+     * Create a view validator out of a schema.
+     */
+    createViewValidator(view: string): AdxViewValidator;
+}
+/**
+ * Validates records using schemas.
+ */
+export declare class AdxRecordValidator {
+    private schemas;
+    type: AdxSchema[];
+    ext: AdxSchema[];
+    constructor(schemas: AdxSchemas, type: AdxSchema[], ext: AdxSchema[]);
+    /**
+     * Returns detailed information about validity and compatibility.
+     */
+    validate(value: SomeObject): AdxValidationResult;
+    /**
+     * Provides a simple boolean check of validity.
+     */
+    isValid(value: any): boolean;
+    /**
+     * Like validate() but throws if validation fails.
+     */
+    assertValid(value: any): AdxValidationResult;
+}
+/**
+ * Validates views using schemas.
+ */
+export declare class AdxViewValidator {
+    view: AdxSchema;
+    constructor(view: AdxSchema);
+    /**
+     * Returns detailed information about validity and compatibility.
+     */
+    validateResponse(value: SomeObject): AdxValidationResult;
+    /**
+     * Provides a simple boolean check of validity.
+     */
+    isResponseValid(value: any): boolean;
+    /**
+     * Like validateResponse() but throws if validation fails.
+     */
+    assertResponseValid(value: any): AdxValidationResult;
+}
+export declare enum AdxValidationResultCode {
+    Full = "full",
+    Partial = "partial",
+    Incompatible = "incompatible",
+    Invalid = "invalid"
+}
+export declare class AdxValidationResult {
+    code: AdxValidationResultCode;
+    /**
+     * The error message (if fatal)
+     */
+    error: string | undefined;
+    /**
+     * A collection of all fallback messages
+     */
+    fallbacks: string[];
+    /**
+     * A collection of all messages
+     */
+    messages: string[];
+    get valid(): boolean;
+    get fullySupported(): boolean;
+    get incompatible(): boolean;
+    /**
+     * Internal - used to transition the state machine.
+     */
+    _t(to: AdxValidationResultCode, message?: string): void;
+    /**
+     * Internal - used to transition the state machine.
+     */
+    _fail(schema: AdxSchema, validator: ValidateFunction): void;
+}
+export declare class AdxValidationError extends Error {
+    code: AdxValidationResultCode;
+    messages: string[];
+    constructor(res: AdxValidationResult);
+}