@atproto/lex-builder 0.1.1 → 0.1.3

package/dist/lex-def-builder.js

@@ -22,9 +22,6 @@ export class LexDefBuilder {
         this.doc = doc;
         this.refResolver = new RefResolver(doc, file, indexer, options);
     }
-    pure(code) {
-        return this.options.pureAnnotations ? markPure(code) : code;
-    }
     async build() {
         this.file.addVariableStatement({
             declarationKind: VariableDeclarationKind.Const,
@@ -89,7 +86,7 @@ export class LexDefBuilder {
     async addPermissionSet(hash, def) {
         const permission = def.permissions.map((def) => {
             const options = stringifyOptions(def, undefined, ['resource', 'type']);
-            return this.pure(`l.permission(${JSON.stringify(def.resource)}, ${options})`);
+            return markPure(`l.permission(${JSON.stringify(def.resource)}, ${options})`);
         });
         const options = stringifyOptions(def, [
             'title',
@@ -98,102 +95,134 @@ export class LexDefBuilder {
             'detail:lang',
         ]);
         await this.addSchema(hash, def, {
-            schema: this.pure(`l.permissionSet($nsid, [${permission.join(',')}], ${options})`),
+            schema: markPure(`l.permissionSet($nsid, [${permission.join(',')}], ${options})`),
+        });
+    }
+    async addParameters(parameters) {
+        const varName = '$params';
+        this.addUtils({
+            [varName]: await this.compileParamsSchema(parameters),
+        });
+        // @TODO Build the types instead of using an inferred type.
+        this.file.addTypeAlias({
+            isExported: true,
+            name: '$Params',
+            type: `l.InferOutput<typeof ${varName}>`,
+            docs: compileDocs(parameters?.description),
+        });
+        return varName;
+    }
+    async addInput(input) {
+        const varName = '$input';
+        this.addUtils({
+            [varName]: await this.compilePayload(input),
+        });
+        // @TODO Build the types instead of using an inferred type.
+        this.file.addTypeAlias({
+            isExported: true,
+            name: '$Input<B = l.BinaryData>',
+            type: `l.InferPayload<typeof ${varName}, B>`,
+            docs: compileDocs(input?.description),
+        });
+        this.file.addTypeAlias({
+            isExported: true,
+            name: '$InputBody<B = l.BinaryData>',
+            type: `l.InferPayloadBody<typeof ${varName}, B>`,
+            docs: compileDocs(input?.description),
         });
+        return varName;
+    }
+    async addOutput(output) {
+        const varName = '$output';
+        this.addUtils({
+            [varName]: await this.compilePayload(output),
+        });
+        // @TODO Build the types instead of using an inferred type.
+        this.file.addTypeAlias({
+            isExported: true,
+            name: '$Output<B = l.BinaryData>',
+            type: `l.InferPayload<typeof ${varName}, B>`,
+            docs: compileDocs(output?.description),
+        });
+        this.file.addTypeAlias({
+            isExported: true,
+            name: '$OutputBody<B = l.BinaryData>',
+            type: `l.InferPayloadBody<typeof ${varName}, B>`,
+            docs: compileDocs(output?.description),
+        });
+        return varName;
+    }
+    async addMessage(message) {
+        const varName = '$message';
+        this.addUtils({
+            [varName]: await this.compileBodySchema(message?.schema),
+        });
+        // @TODO Build the types instead of using an inferred type.
+        this.file.addTypeAlias({
+            isExported: true,
+            name: '$Message',
+            type: `l.InferOutput<typeof ${varName}>`,
+            docs: compileDocs(message?.description),
+        });
+        return varName;
     }
     async addProcedure(hash, def) {
         if (hash !== 'main') {
             throw new Error(`Definition ${hash} cannot be of type ${def.type}`);
         }
-        // @TODO Build the types instead of using an inferred type.
         // Declare each piece of the method as its own top-level exported const
-        // *before* `main`, so consumers that import a single helper (e.g.
-        // `$lxm`) only pull in that subtree rather than the whole procedure.
-        // `main.parameters` etc. would otherwise pin `main` in the module graph.
+        // *before* `main`. This allows to export those pieces individually instead
+        // of "extracting" them from the "main" definition as below, which is bad
+        // for tree-shaking.
+        //
+        // export const $params = main.params`
+        const paramsVar = await this.addParameters(def.parameters);
+        const inputVar = await this.addInput(def.input);
+        const outputVar = await this.addOutput(def.output);
+        await this.addSchema(hash, def, {
+            schema: markPure(`l.procedure($nsid, ${paramsVar}, ${inputVar}, ${outputVar}${formatErrorsArg(await this.compileErrors(def.errors))})`),
+        });
         this.addUtils({
             $lxm: '$nsid',
-            $params: await this.compileParamsSchema(def.parameters),
-            $input: await this.compilePayload(def.input),
-            $output: await this.compilePayload(def.output),
-        });
-        const ref = await this.addSchema(hash, def, {
-            schema: this.pure(`l.procedure($nsid, $params, $input, $output${formatErrorsArg(await this.compileErrors(def.errors))})`),
         });
-        this.addMethodTypeUtils(ref, def);
     }
     async addQuery(hash, def) {
         if (hash !== 'main') {
             throw new Error(`Definition ${hash} cannot be of type ${def.type}`);
         }
-        // @TODO Build the types instead of using an inferred type.
+        // Declare each piece of the method as its own top-level exported const
+        // *before* `main`. This allows to export those pieces individually instead
+        // of "extracting" them from the "main" definition as below, which is bad
+        // for tree-shaking:
+        //
+        // export const $params = main.params
+        const paramsVar = await this.addParameters(def.parameters);
+        const outputVar = await this.addOutput(def.output);
+        await this.addSchema(hash, def, {
+            schema: markPure(`l.query($nsid, ${paramsVar}, ${outputVar}${formatErrorsArg(await this.compileErrors(def.errors))})`),
+        });
         this.addUtils({
             $lxm: '$nsid',
-            $params: await this.compileParamsSchema(def.parameters),
-            $output: await this.compilePayload(def.output),
         });
-        const ref = await this.addSchema(hash, def, {
-            schema: this.pure(`l.query($nsid, $params, $output${formatErrorsArg(await this.compileErrors(def.errors))})`),
-        });
-        this.addMethodTypeUtils(ref, def);
     }
     async addSubscription(hash, def) {
         if (hash !== 'main') {
             throw new Error(`Definition ${hash} cannot be of type ${def.type}`);
         }
-        // @TODO Build the types instead of using an inferred type.
+        // Declare each piece of the method as its own top-level exported const
+        // *before* `main`. This allows to export those pieces individually instead
+        // of "extracting" them from the "main" definition as below, which is bad
+        // for tree-shaking.
+        //
+        // export const $params = main.params`
+        const paramsVar = await this.addParameters(def.parameters);
+        const messageVar = await this.addMessage(def.message);
+        await this.addSchema(hash, def, {
+            schema: markPure(`l.subscription($nsid, ${paramsVar}, ${messageVar}${formatErrorsArg(await this.compileErrors(def.errors))})`),
+        });
         this.addUtils({
             $lxm: '$nsid',
-            $params: await this.compileParamsSchema(def.parameters),
-            $message: await this.compileBodySchema(def.message?.schema),
-        });
-        const ref = await this.addSchema(hash, def, {
-            schema: this.pure(`l.subscription($nsid, $params, $message${formatErrorsArg(await this.compileErrors(def.errors))})`),
-        });
-        this.addMethodTypeUtils(ref, def);
-    }
-    addMethodTypeUtils(ref, def) {
-        this.file.addTypeAlias({
-            isExported: true,
-            name: '$Params',
-            type: `l.InferMethodParams<typeof ${ref.varName}>`,
-            docs: compileDocs(def.parameters?.description),
         });
-        if (def.type === 'procedure') {
-            this.file.addTypeAlias({
-                isExported: true,
-                name: '$Input<B = l.BinaryData>',
-                type: `l.InferMethodInput<typeof ${ref.varName}, B>`,
-                docs: compileDocs(def.input?.description),
-            });
-            this.file.addTypeAlias({
-                isExported: true,
-                name: '$InputBody<B = l.BinaryData>',
-                type: `l.InferMethodInputBody<typeof ${ref.varName}, B>`,
-                docs: compileDocs(def.input?.description),
-            });
-        }
-        if (def.type === 'procedure' || def.type === 'query') {
-            this.file.addTypeAlias({
-                isExported: true,
-                name: '$Output<B = l.BinaryData>',
-                type: `l.InferMethodOutput<typeof ${ref.varName}, B>`,
-                docs: compileDocs(def.output?.description),
-            });
-            this.file.addTypeAlias({
-                isExported: true,
-                name: '$OutputBody<B = l.BinaryData>',
-                type: `l.InferMethodOutputBody<typeof ${ref.varName}, B>`,
-                docs: compileDocs(def.output?.description),
-            });
-        }
-        if (def.type === 'subscription') {
-            this.file.addTypeAlias({
-                isExported: true,
-                name: '$Message',
-                type: `l.InferSubscriptionMessage<typeof ${ref.varName}>`,
-                docs: compileDocs(def.message?.description),
-            });
-        }
     }
     async addRecord(hash, def) {
         if (hash !== 'main') {
@@ -205,7 +234,7 @@ export class LexDefBuilder {
         properties.unshift(`$type: ${JSON.stringify(l.$type(this.doc.id, hash))}`);
         await this.addSchema(hash, def, {
             type: `{ ${properties.join(';')} }`,
-            schema: (ref) => this.pure(`l.record<${key}, ${ref.typeName}>(${key}, $nsid, ${objectSchema})`),
+            schema: (ref) => markPure(`l.record<${key}, ${ref.typeName}>(${key}, $nsid, ${objectSchema})`),
             objectUtils: true,
             validationUtils: true,
         });
@@ -216,14 +245,14 @@ export class LexDefBuilder {
         properties.unshift(`$type?: ${JSON.stringify(l.$type(this.doc.id, hash))}`);
         await this.addSchema(hash, def, {
             type: `{ ${properties.join(';')} }`,
-            schema: (ref) => this.pure(`l.typedObject<${ref.typeName}>($nsid, ${JSON.stringify(hash)}, ${objectSchema})`),
+            schema: (ref) => markPure(`l.typedObject<${ref.typeName}>($nsid, ${JSON.stringify(hash)}, ${objectSchema})`),
             objectUtils: true,
             validationUtils: true,
         });
     }
     async addToken(hash, def) {
         await this.addSchema(hash, def, {
-            schema: this.pure(`l.token($nsid, ${JSON.stringify(hash)})`),
+            schema: markPure(`l.token($nsid, ${JSON.stringify(hash)})`),
             type: JSON.stringify(l.$type(this.doc.id, hash)),
             validationUtils: true,
         });
@@ -241,7 +270,7 @@ export class LexDefBuilder {
             type: `(${await this.compileContainedType(def.items)})[]`,
             // @NOTE Not using compileArraySchema to allow specifying the generic
             // parameter to l.array<>.
-            schema: (ref) => this.pure(`l.array<${ref.typeName}[number]>(${itemSchema}, ${options})`),
+            schema: (ref) => markPure(`l.array<${ref.typeName}[number]>(${itemSchema}, ${options})`),
             validationUtils: true,
         });
     }
@@ -290,9 +319,9 @@ export class LexDefBuilder {
         }
         if (hash === 'main' && objectUtils) {
             this.addUtils({
+                $type: `$nsid`,
                 $isTypeOf: markPure(`${ref.varName}.isTypeOf.bind(${ref.varName})`),
                 $build: markPure(`${ref.varName}.build.bind(${ref.varName})`),
-                $type: `${ref.varName}.$type`,
             });
         }
         if (hash === 'main' && validationUtils) {
@@ -312,19 +341,19 @@ export class LexDefBuilder {
     }
     async compilePayload(def) {
         if (!def)
-            return this.pure(`l.payload()`);
+            return markPure(`l.payload()`);
         // Special case for JSON object payloads
         if (def.encoding === 'application/json' && def.schema?.type === 'object') {
             const properties = await this.compilePropertiesSchemas(def.schema);
-            return this.pure(`l.jsonPayload({${properties.join(',')}})`);
+            return markPure(`l.jsonPayload({${properties.join(',')}})`);
         }
         const encodedEncoding = JSON.stringify(def.encoding);
         if (def.schema) {
             const bodySchema = await this.compileBodySchema(def.schema);
-            return this.pure(`l.payload(${encodedEncoding}, ${bodySchema})`);
+            return markPure(`l.payload(${encodedEncoding}, ${bodySchema})`);
         }
         else {
-            return this.pure(`l.payload(${encodedEncoding})`);
+            return markPure(`l.payload(${encodedEncoding})`);
         }
     }
     async compileBodySchema(def) {
@@ -336,9 +365,9 @@ export class LexDefBuilder {
     }
     async compileParamsSchema(def) {
         if (!def)
-            return this.pure(`l.params()`);
+            return markPure(`l.params()`);
         const properties = await this.compilePropertiesSchemas(def);
-        return this.pure(properties.length === 0
+        return markPure(properties.length === 0
             ? `l.params()`
             : `l.params({${properties.join(',')}})`);
     }
@@ -349,7 +378,7 @@ export class LexDefBuilder {
     }
     async compileObjectSchema(def) {
         const properties = await this.compilePropertiesSchemas(def);
-        return this.pure(`l.object({${properties.join(',')}})`);
+        return markPure(`l.object({${properties.join(',')}})`);
     }
     async compilePropertiesSchemas(options) {
         for (const opt of ['required', 'nullable']) {
@@ -375,10 +404,10 @@ export class LexDefBuilder {
         const isRequired = options.required?.includes(key);
         let schema = await this.compileContainedSchema(def);
         if (isNullable) {
-            schema = this.pure(`l.nullable(${schema})`);
+            schema = markPure(`l.nullable(${schema})`);
         }
         if (!isRequired) {
-            schema = this.pure(`l.optional(${schema})`);
+            schema = markPure(`l.optional(${schema})`);
         }
         return `${JSON.stringify(key)}:${schema}`;
     }
@@ -452,13 +481,13 @@ export class LexDefBuilder {
             'minLength',
             'maxLength',
         ]);
-        return this.pure(`l.array(${itemSchema}, ${options})`);
+        return markPure(`l.array(${itemSchema}, ${options})`);
     }
     async compileArrayType(def) {
         return `(${await this.compileContainedType(def.items)})[]`;
     }
     async compileUnknownSchema(_def) {
-        return this.pure(`l.lexMap()`);
+        return markPure(`l.lexMap()`);
     }
     async compileUnknownType(_def) {
         return `l.LexMap`;
@@ -466,7 +495,7 @@ export class LexDefBuilder {
     withDefault(schema, defaultValue) {
         if (defaultValue === undefined)
             return schema;
-        return this.pure(`l.withDefault(${schema}, ${JSON.stringify(defaultValue)})`);
+        return markPure(`l.withDefault(${schema}, ${JSON.stringify(defaultValue)})`);
     }
     async compileBooleanSchema(def) {
         const schema = l.boolean();
@@ -475,7 +504,7 @@ export class LexDefBuilder {
         }
         if (hasConst(def))
             return this.compileConstSchema(def);
-        return this.withDefault(this.pure(`l.boolean()`), def.default);
+        return this.withDefault(markPure(`l.boolean()`), def.default);
     }
     async compileBooleanType(def) {
         if (hasConst(def))
@@ -502,7 +531,7 @@ export class LexDefBuilder {
             'maximum',
             'minimum',
         ]);
-        return this.withDefault(this.pure(`l.integer(${options})`), def.default);
+        return this.withDefault(markPure(`l.integer(${options})`), def.default);
     }
     async compileIntegerType(def) {
         if (hasConst(def))
@@ -547,7 +576,7 @@ export class LexDefBuilder {
                 'knownValues',
             ])
             : undefined;
-        return this.withDefault(this.pure(`l.string${generic ? `<${generic}>` : ''}(${options})`), def.default);
+        return this.withDefault(markPure(`l.string${generic ? `<${generic}>` : ''}(${options})`), def.default);
     }
     async compileStringType(def) {
         if (hasConst(def))
@@ -593,7 +622,7 @@ export class LexDefBuilder {
             'minLength',
             'maxLength',
         ]);
-        return this.pure(`l.bytes(${options})`);
+        return markPure(`l.bytes(${options})`);
     }
     async compileBytesType(_def) {
         return 'Uint8Array';
@@ -603,13 +632,13 @@ export class LexDefBuilder {
             'maxSize',
             'accept',
         ]);
-        return this.pure(`l.blob(${options})`);
+        return markPure(`l.blob(${options})`);
     }
     async compileBlobType(_def) {
         return 'l.BlobRef';
     }
     async compileCidLinkSchema(_def) {
-        return this.pure(`l.cid()`);
+        return markPure(`l.cid()`);
     }
     async compileCidLinkType(_def) {
         return 'l.Cid';
@@ -618,7 +647,7 @@ export class LexDefBuilder {
         const { varName, typeName } = await this.refResolver.resolve(def.ref);
         // @NOTE "as any" is needed in schemas with circular refs as TypeScript
         // cannot infer the type of a value that depends on its initializer type
-        return this.pure(`l.ref<${typeName}>((() => ${varName}) as any)`);
+        return markPure(`l.ref<${typeName}>((() => ${varName}) as any)`);
     }
     async compileRefType(def) {
         const ref = await this.refResolver.resolve(def.ref);
@@ -626,15 +655,15 @@ export class LexDefBuilder {
     }
     async compileRefUnionSchema(def) {
         if (def.refs.length === 0 && def.closed) {
-            return this.pure(`l.never()`);
+            return markPure(`l.never()`);
         }
         const refs = await Promise.all(def.refs.map(async (ref) => {
             const { varName, typeName } = await this.refResolver.resolve(ref);
             // @NOTE "as any" is needed in schemas with circular refs as TypeScript
             // cannot infer the type of a value that depends on its initializer type
-            return this.pure(`l.typedRef<${typeName}>((() => ${varName}) as any)`);
+            return markPure(`l.typedRef<${typeName}>((() => ${varName}) as any)`);
         }));
-        return this.pure(`l.typedUnion([${refs.join(',')}], ${def.closed ?? false})`);
+        return markPure(`l.typedUnion([${refs.join(',')}], ${def.closed ?? false})`);
     }
     async compileRefUnionType(def) {
         const types = await Promise.all(def.refs.map(async (ref) => {
@@ -647,9 +676,9 @@ export class LexDefBuilder {
     }
     async compileConstSchema(def) {
         if (hasEnum(def) && !def.enum.includes(def.const)) {
-            return this.pure(`l.never()`);
+            return markPure(`l.never()`);
         }
-        const result = this.pure(`l.literal(${JSON.stringify(def.const)})`);
+        const result = markPure(`l.literal(${JSON.stringify(def.const)})`);
         return this.withDefault(result, def.default);
     }
     async compileConstType(def) {
@@ -660,11 +689,11 @@ export class LexDefBuilder {
     }
     async compileEnumSchema(def) {
         if (def.enum.length === 0) {
-            return this.pure(`l.never()`);
+            return markPure(`l.never()`);
         }
         const result = def.enum.length === 1
-            ? this.pure(`l.literal(${JSON.stringify(def.enum[0])})`)
-            : this.pure(`l.enum(${JSON.stringify(def.enum)})`);
+            ? markPure(`l.literal(${JSON.stringify(def.enum[0])})`)
+            : markPure(`l.enum(${JSON.stringify(def.enum)})`);
         return this.withDefault(result, def.default);
     }
     async compileEnumType(def) {