@atcute/lex-cli 1.1.2 → 2.0.0

package/cli.mjs

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-import './dist/index.js';
+import './dist/cli.js';

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli.js

@@ -0,0 +1,77 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { Builtins, Command, Option, Program } from '@externdefs/collider';
+import pc from 'picocolors';
+import { generateLexiconApi } from './codegen.js';
+import { lexiconDoc } from './schema.js';
+const program = new Program({ binaryName: 'lex-cli' });
+program.register(Builtins.HelpCommand);
+program.register(class GenerateCommand extends Command {
+    static paths = [['generate']];
+    static usage = Command.Usage({
+        description: `Generates TypeScript schema`,
+    });
+    config = Option.String(['-c', '--config'], {
+        required: true,
+        description: `Config file`,
+    });
+    async execute() {
+        const configFilename = path.resolve(this.config);
+        const configDirname = path.dirname(configFilename);
+        let config;
+        try {
+            const mod = (await import(path.resolve(configFilename)));
+            config = mod.default;
+        }
+        catch (err) {
+            console.error(pc.bold(pc.red(`failed to import config:`)));
+            console.error(err);
+            return 1;
+        }
+        const documents = [];
+        for await (const filename of fs.glob(config.files, { cwd: configDirname })) {
+            let source;
+            try {
+                source = await fs.readFile(path.join(configDirname, filename), 'utf8');
+            }
+            catch (err) {
+                console.error(pc.bold(pc.red(`file read error with "${filename}"`)));
+                console.error(err);
+                return 1;
+            }
+            let json;
+            try {
+                json = JSON.parse(source);
+            }
+            catch (err) {
+                console.error(pc.bold(pc.red(`json parse error in "${filename}"`)));
+                console.error(err);
+                return 1;
+            }
+            const result = lexiconDoc.try(json, { mode: 'strip' });
+            if (!result.ok) {
+                console.error(pc.bold(pc.red(`schema validation failed for "${filename}"`)));
+                for (const issue of result.issues) {
+                    console.log(`- ${issue.code} at .${issue.path.join('.')}`);
+                }
+                return 1;
+            }
+            documents.push(result.value);
+        }
+        const result = await generateLexiconApi({
+            documents: documents,
+            mappings: config.mappings ?? [],
+            prettier: {},
+        });
+        const outdir = path.join(configDirname, config.outdir);
+        for (const file of result.files) {
+            const filename = path.join(outdir, file.filename);
+            const dirname = path.dirname(filename);
+            await fs.mkdir(dirname, { recursive: true });
+            await fs.writeFile(filename, file.code);
+        }
+    }
+});
+const exitCode = await program.run(process.argv.slice(2));
+process.exitCode = exitCode;
+//# sourceMappingURL=cli.js.map

package/dist/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.js","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"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"}

package/dist/codegen.d.ts

@@ -0,0 +1,23 @@
+import type { LexiconDoc } from './schema.js';
+export interface SourceFile {
+    filename: string;
+    code: string;
+}
+export interface ImportMapping {
+    nsid: string[];
+    imports: string | ((nsid: string) => {
+        type: 'named' | 'namespace';
+        from: string;
+    });
+}
+export interface LexiconApiOptions {
+    documents: LexiconDoc[];
+    mappings: ImportMapping[];
+    prettier?: {
+        cwd?: string;
+    };
+}
+export interface LexiconApiResult {
+    files: SourceFile[];
+}
+export declare const generateLexiconApi: (opts: LexiconApiOptions) => Promise<LexiconApiResult>;

package/dist/codegen.js

@@ -0,0 +1,552 @@
+import { dirname as getDirname, relative as getRelativePath } from 'node:path/posix';
+import * as prettier from 'prettier';
+const lit = JSON.stringify;
+const resolveExternalImport = (nsid, mappings) => {
+    return mappings.find((mapping) => {
+        return mapping.nsid.some((pattern) => {
+            if (pattern.endsWith('.*')) {
+                return nsid.startsWith(pattern.slice(0, -1));
+            }
+            return nsid === pattern;
+        });
+    });
+};
+const PURE = `/*#__PURE__*/`;
+export const generateLexiconApi = async (opts) => {
+    const documents = opts.documents.toSorted((a, b) => {
+        if (a.id < b.id) {
+            return -1;
+        }
+        if (a.id > b.id) {
+            return 1;
+        }
+        return 0;
+    });
+    const map = new Map(documents.map((doc) => [doc.id, doc]));
+    const files = [];
+    for (const doc of documents) {
+        const filename = `types/${doc.id.replaceAll('.', '/')}.ts`;
+        const file = {
+            imports: '',
+            rawschemas: '',
+            schemadefs: '',
+            schemas: '',
+            interfaces: '',
+            exports: '',
+            ambients: '',
+        };
+        file.imports += `import type {} from '@atcute/lexicons';\n`;
+        file.imports += `import * as v from '@atcute/lexicons/validations';\n`;
+        const imports = new Set();
+        const sortedDefIds = Object.keys(doc.defs).toSorted((a, b) => {
+            if (a < b) {
+                return -1;
+            }
+            if (a > b) {
+                return 1;
+            }
+            return 0;
+        });
+        for (const defId of sortedDefIds) {
+            const def = doc.defs[defId];
+            const defUri = `${doc.id}#${defId}`;
+            const camelcased = toCamelCase(defId);
+            const varname = `${camelcased}Schema`;
+            let result;
+            switch (def.type) {
+                case 'query': {
+                    result = generateXrpcQuery(imports, defUri, def);
+                    file.imports += `import type {} from '@atcute/lexicons/ambient';\n`;
+                    file.ambients += `declare module '@atcute/lexicons/ambient' {\n`;
+                    file.ambients += `  interface XRPCQueries {\n`;
+                    file.ambients += `    ${lit(stripMainHash(defUri))}: ${camelcased}Schema;\n`;
+                    file.ambients += `  }\n`;
+                    file.ambients += `}`;
+                    break;
+                }
+                case 'procedure': {
+                    result = generateXrpcProcedure(imports, defUri, def);
+                    file.imports += `import type {} from '@atcute/lexicons/ambient';\n`;
+                    file.ambients += `declare module '@atcute/lexicons/ambient' {\n`;
+                    file.ambients += `  interface XRPCProcedures {\n`;
+                    file.ambients += `    ${lit(stripMainHash(defUri))}: ${camelcased}Schema;\n`;
+                    file.ambients += `  }\n`;
+                    file.ambients += `}`;
+                    break;
+                }
+                case 'subscription': {
+                    result = generateXrpcSubscription(imports, defUri, def);
+                    file.imports += `import type {} from '@atcute/lexicons/ambient';\n`;
+                    file.ambients += `declare module '@atcute/lexicons/ambient' {\n`;
+                    file.ambients += `  interface XRPCSubscriptions {\n`;
+                    file.ambients += `    ${lit(stripMainHash(defUri))}: ${camelcased}Schema;\n`;
+                    file.ambients += `  }\n`;
+                    file.ambients += `}`;
+                    break;
+                }
+                case 'object': {
+                    result = generateObject(imports, defUri, def);
+                    break;
+                }
+                case 'record': {
+                    result = generateRecord(imports, defUri, def);
+                    file.imports += `import type {} from '@atcute/lexicons/ambient';\n`;
+                    file.ambients += `declare module '@atcute/lexicons/ambient' {\n`;
+                    file.ambients += `  interface Records {\n`;
+                    file.ambients += `    ${lit(stripMainHash(defUri))}: ${camelcased}Schema;\n`;
+                    file.ambients += `  }\n`;
+                    file.ambients += `}`;
+                    break;
+                }
+                case 'token': {
+                    result = `${PURE} v.literal(${lit(stripMainHash(defUri))})`;
+                    break;
+                }
+                default: {
+                    result = generateType(imports, defUri, def);
+                    break;
+                }
+            }
+            file.rawschemas += `const _${varname} = ${result};\n`;
+            file.schemadefs += `type ${camelcased}$schematype = typeof _${varname};\n`;
+            file.schemas += `export interface ${camelcased}Schema extends ${camelcased}$schematype {}\n`;
+            file.exports += `export const ${varname} = _${varname} as ${camelcased}Schema;\n`;
+            switch (def.type) {
+                case 'array':
+                case 'object':
+                case 'record':
+                case 'unknown': {
+                    file.interfaces += `export interface ${toTitleCase(defId)} extends v.InferInput<typeof ${varname}> {}\n`;
+                    break;
+                }
+                case 'blob':
+                case 'boolean':
+                case 'bytes':
+                case 'cid-link':
+                case 'integer':
+                case 'string':
+                case 'token': {
+                    file.interfaces += `export type ${toTitleCase(defId)} = v.InferInput<typeof ${varname}>;\n`;
+                    break;
+                }
+            }
+        }
+        {
+            const dirname = getDirname(filename);
+            const sortedImports = [...imports].toSorted((a, b) => {
+                if (a < b) {
+                    return -1;
+                }
+                if (a > b) {
+                    return 1;
+                }
+                return 0;
+            });
+            for (const ns of sortedImports) {
+                const local = map.get(ns);
+                if (local) {
+                    const target = `types/${ns.replaceAll('.', '/')}.js`;
+                    let relative = getRelativePath(dirname, target);
+                    if (!relative.startsWith('.')) {
+                        relative = `./${relative}`;
+                    }
+                    file.imports += `import * as ${toTitleCase(ns)} from ${lit(relative)};\n`;
+                    continue;
+                }
+                const external = resolveExternalImport(ns, opts.mappings);
+                if (external) {
+                    if (typeof external.imports === 'function') {
+                        const res = external.imports(ns);
+                        if (res.type === 'named') {
+                            file.imports += `import { ${toTitleCase(ns)} } from ${lit(res.from)};\n`;
+                        }
+                        else if (res.type === 'namespace') {
+                            file.imports += `import * as ${toTitleCase(ns)} from ${lit(res.from)};\n`;
+                        }
+                    }
+                    else {
+                        file.imports += `import { ${toTitleCase(ns)} } from ${lit(external.imports)};\n`;
+                    }
+                    continue;
+                }
+                throw new Error(`'${doc.id}' referenced non-existent '${ns}' namespace`);
+            }
+        }
+        files.push({
+            filename: filename,
+            code: file.imports +
+                `\n\n` +
+                file.rawschemas +
+                `\n\n` +
+                file.schemadefs +
+                `\n\n` +
+                file.schemas +
+                `\n\n` +
+                file.exports +
+                `\n\n` +
+                file.interfaces +
+                `\n\n` +
+                file.ambients,
+        });
+    }
+    {
+        let code = ``;
+        for (const doc of map.values()) {
+            code += `export * as ${toTitleCase(doc.id)} from ${lit(`./types/${doc.id.replaceAll('.', '/')}.js`)};\n`;
+        }
+        files.push({
+            filename: 'index.ts',
+            code: code,
+        });
+    }
+    if (opts.prettier) {
+        const config = await prettier.resolveConfig(opts.prettier.cwd ?? process.cwd(), { editorconfig: true });
+        for (const file of files) {
+            const formatted = await prettier.format(file.code, { ...config, parser: 'typescript' });
+            file.code = formatted;
+        }
+    }
+    return { files };
+};
+const generateXrpcQuery = (imports, defUri, spec) => {
+    const params = generateXrpcParameters(imports, defUri, spec.parameters);
+    const output = generateXrpcBody(imports, defUri, spec.output);
+    return `${PURE} v.query(${lit(stripMainHash(defUri))}, {\n"params": ${params}, "output": ${output} })`;
+};
+const generateXrpcProcedure = (imports, defUri, spec) => {
+    const params = generateXrpcParameters(imports, defUri, spec.parameters);
+    const input = generateXrpcBody(imports, defUri, spec.input);
+    const output = generateXrpcBody(imports, defUri, spec.output);
+    return `${PURE} v.procedure(${lit(stripMainHash(defUri))}, {\n"params": ${params}, "input": ${input}, "output": ${output} })`;
+};
+const generateXrpcSubscription = (imports, defUri, spec) => {
+    const schema = spec.message?.schema;
+    const params = generateXrpcParameters(imports, defUri, spec.parameters);
+    let inner = ``;
+    inner += `"params": ${params},`;
+    if (schema) {
+        if (schema.type === 'object') {
+            const res = generateObject(imports, defUri, schema, 'none');
+            inner += `"message": ${res},`;
+        }
+        else {
+            const res = generateType(imports, defUri, schema);
+            inner += `get "message" () { return ${res} },`;
+        }
+    }
+    else {
+        inner += `"message": null,`;
+    }
+    return `${PURE} v.subscription(${lit(stripMainHash(defUri))}, {\n${inner}})`;
+};
+const generateXrpcBody = (imports, defUri, spec) => {
+    if (spec === undefined) {
+        return `null`;
+    }
+    const schema = spec.schema;
+    const encoding = spec.encoding;
+    if (schema) {
+        let inner = ``;
+        inner += `"type": "lex",`;
+        if (schema.type === 'object') {
+            const res = generateObject(imports, defUri, schema, 'none');
+            inner += `"schema": ${res},`;
+        }
+        else {
+            const res = generateType(imports, defUri, schema);
+            inner += `get "schema" () { return ${res} },`;
+        }
+        return `{\n${inner}}`;
+    }
+    if (encoding) {
+        return `{\n"type": "blob" }`;
+    }
+    return `null`;
+};
+const generateXrpcParameters = (imports, defUri, spec) => {
+    if (spec === undefined) {
+        return `null`;
+    }
+    const mask = {
+        type: 'object',
+        description: spec.description,
+        required: spec.required,
+        properties: spec.properties,
+    };
+    return generateObject(imports, defUri, mask, 'none');
+};
+const generateRecord = (imports, defUri, spec) => {
+    const schema = generateObject(imports, defUri, spec.record, 'required');
+    let key = `${PURE} v.string()`;
+    if (spec.key) {
+        if (spec.key === 'tid') {
+            key = `${PURE} v.tidString()`;
+        }
+        else if (spec.key === 'nsid') {
+            key = `${PURE} v.nsidString()`;
+        }
+        else if (spec.key.startsWith('literal:')) {
+            key = `${PURE} v.literal(${lit(spec.key.slice('literal:'.length))})`;
+        }
+    }
+    return `${PURE} v.record(${key}, ${schema})`;
+};
+const generateObject = (imports, defUri, spec, writeType = 'optional') => {
+    const required = new Set(spec.required);
+    const nullable = new Set(spec.nullable);
+    let inner = ``;
+    switch (writeType) {
+        case 'optional': {
+            inner += `"$type": ${PURE} v.optional(${PURE} v.literal(${lit(stripMainHash(defUri))})),`;
+            break;
+        }
+        case 'required': {
+            inner += `"$type": ${PURE} v.literal(${lit(stripMainHash(defUri))}),`;
+            break;
+        }
+    }
+    for (const [prop, propSpec] of Object.entries(spec.properties ?? {})) {
+        const lazy = isRefVariant(propSpec.type === 'array' ? propSpec.items : propSpec);
+        const optional = !required.has(prop) && !('default' in propSpec);
+        const nulled = nullable.has(prop);
+        let call = generateType(imports, defUri, propSpec, lazy);
+        if (nulled) {
+            call = `${PURE} v.nullable(${call})`;
+        }
+        if (optional) {
+            call = `${PURE} v.optional(${call})`;
+        }
+        if (lazy) {
+            inner += `get ${lit(prop)} () { return ${call} },`;
+        }
+        else {
+            inner += `${lit(prop)}: ${call},`;
+        }
+    }
+    return `${PURE} v.object({\n${inner}})`;
+};
+const generateType = (imports, defUri, spec, lazy = false) => {
+    switch (spec.type) {
+        // LexRefVariant
+        case 'ref': {
+            const ref = spec.ref;
+            if (ref.startsWith('#')) {
+                const id = ref.slice(1);
+                return `${toCamelCase(id)}Schema`;
+            }
+            else {
+                const [ns, id = 'main'] = ref.split('#');
+                if (ns === stripHash(defUri)) {
+                    return `${toCamelCase(id)}Schema`;
+                }
+                imports.add(ns);
+                return `${toTitleCase(ns)}.${toCamelCase(id)}Schema`;
+            }
+        }
+        case 'union': {
+            const refs = spec.refs.map((ref) => {
+                if (ref.startsWith('#')) {
+                    const id = ref.slice(1);
+                    return `${toCamelCase(id)}Schema`;
+                }
+                else {
+                    const [ns, id = 'main'] = ref.split('#');
+                    if (ns === stripHash(defUri)) {
+                        return `${toCamelCase(id)}Schema`;
+                    }
+                    imports.add(ns);
+                    return `${toTitleCase(ns)}.${toCamelCase(id)}Schema`;
+                }
+            });
+            return `${PURE} v.variant([${refs.join(', ')}]${spec.closed ? `, true` : ``})`;
+        }
+        // LexArray
+        case 'array': {
+            let item = generateType(imports, defUri, spec.items);
+            if (!lazy && (spec.items.type === 'ref' || spec.items.type === 'union')) {
+                item = `(() => { return ${item}; })`;
+            }
+            let pipe = [];
+            if ((spec.minLength ?? 0) > 0 || spec.maxLength !== undefined) {
+                if (spec.maxLength === undefined) {
+                    pipe.push(`${PURE} v.arrayLength(${lit(spec.minLength ?? 0)})`);
+                }
+                else {
+                    pipe.push(`${PURE} v.arrayLength(${lit(spec.minLength ?? 0)}, ${lit(spec.maxLength)})`);
+                }
+            }
+            if (pipe.length === 0) {
+                return `${PURE} v.array(${item})`;
+            }
+            else {
+                return `${PURE} v.constrain(v.array(${item}), [ ${pipe.join(', ')} ])`;
+            }
+        }
+        // LexPrimitive
+        case 'boolean': {
+            if (spec.const !== undefined) {
+                return `${PURE} v.literal(${spec.const})`;
+            }
+            let call = `${PURE} v.boolean()`;
+            if (spec.default !== undefined) {
+                call = `${PURE} v.optional(${call}, ${lit(spec.default)})`;
+            }
+            return call;
+        }
+        case 'integer': {
+            if (spec.const !== undefined) {
+                return `${PURE} v.literal(${lit(spec.const)})`;
+            }
+            if (spec.enum !== undefined) {
+                return `${PURE} v.literalEnum(${lit(spec.enum)})`;
+            }
+            let pipe = [];
+            if ((spec.minimum ?? 0) > 0 || spec.maximum !== undefined) {
+                if (spec.maximum === undefined) {
+                    pipe.push(`${PURE} v.integerRange(${lit(spec.minimum ?? 0)})`);
+                }
+                else {
+                    pipe.push(`${PURE} v.integerRange(${lit(spec.minimum ?? 0)}, ${lit(spec.maximum)})`);
+                }
+            }
+            let call = `${PURE} v.integer()`;
+            if (pipe.length !== 0) {
+                call = `${PURE} v.constrain(${call}, [ ${pipe.join(', ')} ])`;
+            }
+            if (spec.default !== undefined) {
+                call = `${PURE} v.optional(${call}, ${lit(spec.default)})`;
+            }
+            return call;
+        }
+        case 'string': {
+            if (spec.const !== undefined) {
+                return `${PURE} v.literal(${lit(spec.const)})`;
+            }
+            if (spec.enum !== undefined) {
+                return `${PURE} v.literalEnum(${lit(spec.enum)})`;
+            }
+            let pipe = [];
+            if ((spec.minLength ?? 0) > 0 || spec.maxLength !== undefined) {
+                if (spec.maxLength === undefined) {
+                    pipe.push(`${PURE} v.stringLength(${lit(spec.minLength ?? 0)})`);
+                }
+                else {
+                    pipe.push(`${PURE} v.stringLength(${lit(spec.minLength ?? 0)}, ${lit(spec.maxLength)})`);
+                }
+            }
+            if ((spec.minGraphemes ?? 0) > 0 || spec.maxGraphemes !== undefined) {
+                if (spec.maxGraphemes === undefined) {
+                    pipe.push(`${PURE} v.stringGraphemes(${lit(spec.minGraphemes ?? 0)})`);
+                }
+                else {
+                    pipe.push(`${PURE} v.stringGraphemes(${lit(spec.minGraphemes ?? 0)}, ${lit(spec.maxGraphemes)})`);
+                }
+            }
+            let call = `${PURE} v.string()`;
+            if (spec.knownValues?.length) {
+                call = `${PURE} v.string<${spec.knownValues.map(lit).join(' | ')} | (string & {})>()`;
+            }
+            switch (spec.format) {
+                case 'at-identifier': {
+                    call = `${PURE} v.actorIdentifierString()`;
+                    break;
+                }
+                case 'at-uri': {
+                    call = `${PURE} v.resourceUriString()`;
+                    break;
+                }
+                case 'datetime': {
+                    call = `${PURE} v.datetimeString()`;
+                    break;
+                }
+                case 'did': {
+                    call = `${PURE} v.didString()`;
+                    break;
+                }
+                case 'handle': {
+                    call = `${PURE} v.handleString()`;
+                    break;
+                }
+                case 'language': {
+                    call = `${PURE} v.languageCodeString()`;
+                    break;
+                }
+                case 'nsid': {
+                    call = `${PURE} v.nsidString()`;
+                    break;
+                }
+                case 'record-key': {
+                    call = `${PURE} v.recordKeyString()`;
+                    break;
+                }
+                case 'tid': {
+                    call = `${PURE} v.tidString()`;
+                    break;
+                }
+                case 'uri': {
+                    call = `${PURE} v.genericUriString()`;
+                    break;
+                }
+            }
+            if (pipe.length !== 0) {
+                call = `${PURE} v.constrain(${call}, [ ${pipe.join(', ')} ])`;
+            }
+            if (spec.default !== undefined) {
+                call = `${PURE} v.optional(${call}, ${lit(spec.default)})`;
+            }
+            return call;
+        }
+        case 'unknown': {
+            return `${PURE} v.unknown()`;
+        }
+        // LexBlob
+        case 'blob': {
+            return `${PURE} v.blob()`;
+        }
+        // LexIpldType
+        case 'bytes': {
+            let pipe = [];
+            if ((spec.minLength ?? 0) > 0 || spec.maxLength !== undefined) {
+                if (spec.maxLength === undefined) {
+                    pipe.push(`${PURE} v.bytesSize(${lit(spec.minLength ?? 0)})`);
+                }
+                else {
+                    pipe.push(`${PURE} v.bytesSize(${lit(spec.minLength ?? 0)}, ${lit(spec.maxLength)})`);
+                }
+            }
+            let call = `${PURE} v.bytes()`;
+            if (pipe.length !== 0) {
+                call = `${PURE} v.constrain(${call}, [ ${pipe.join(', ')} ])`;
+            }
+            return call;
+        }
+        case 'cid-link': {
+            return `${PURE} v.cidLink()`;
+        }
+    }
+};
+const isRefVariant = (spec) => {
+    const type = spec.type;
+    return type === 'ref' || type === 'union';
+};
+const stripHash = (defUri) => {
+    const index = defUri.indexOf('#');
+    if (index === -1) {
+        return defUri;
+    }
+    return defUri.slice(0, index);
+};
+const stripMainHash = (defUri) => {
+    return defUri.endsWith('#main') ? defUri.slice(0, -'#main'.length) : defUri;
+};
+const toTitleCase = (v) => {
+    v = v.replace(/^([a-z])/gi, (_, g) => g.toUpperCase());
+    v = v.replace(/[.#-]([a-z])/gi, (_, g) => g.toUpperCase());
+    return v.replace(/[.-]/g, '');
+};
+const toCamelCase = (v) => {
+    v = v.replace(/^([A-Z])/gi, (_, g) => g.toLowerCase());
+    v = v.replace(/[.#-]([a-z])/gi, (_, g) => g.toUpperCase());
+    return v.replace(/[.-]/g, '');
+};
+//# sourceMappingURL=codegen.js.map