graphql-typescript-definitions/lib/cli.js

"use strict";
/* eslint no-console: off */
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
    result["default"] = mod;
    return result;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const yargs = __importStar(require("yargs"));
const chalk_1 = __importDefault(require("chalk"));
const types_1 = require("./types");
const _1 = require(".");
const argv = yargs
    .usage('Usage: $0 [options]')
    .option('watch', {
    required: false,
    default: false,
    type: 'boolean',
    describe: 'Watch the GraphQL files for changes and re-run the generation',
})
    .option('cwd', {
    required: false,
    default: process.cwd(),
    normalize: true,
    type: 'string',
    describe: 'Working directory to use',
})
    .option('schema-types-path', {
    required: true,
    normalize: true,
    type: 'string',
    describe: 'The path to output concrete schema types',
})
    .option('add-typename', {
    required: false,
    default: true,
    type: 'boolean',
    describe: 'Add a __typename field to every object type',
})
    .option('enum-format', {
    required: false,
    type: 'string',
    describe: 'The format in which to generate case names for enum types in the schema',
    choices: [
        types_1.EnumFormat.CamelCase,
        types_1.EnumFormat.PascalCase,
        types_1.EnumFormat.SnakeCase,
        types_1.EnumFormat.ScreamingSnakeCase,
    ],
})
    .option('custom-scalars', {
    required: false,
    default: '{}',
    type: 'string',
    describe: 'A JSON-serialized object where the key is the name of a custom scalar, and the value is an object with the name and package from which to import the type to use for that scalar',
})
    .help().argv;
const builder = new _1.Builder({
    cwd: argv.cwd,
    schemaTypesPath: argv.schemaTypesPath,
    addTypename: argv.addTypename,
    enumFormat: argv.enumFormat,
    customScalars: normalizeCustomScalars(argv.customScalars),
});
function normalizeCustomScalars(customScalarOption) {
    try {
        const result = JSON.parse(customScalarOption);
        return typeof result === 'object' ? result : undefined;
    }
    catch (error) {
        return undefined;
    }
}
const schemas = [];
const docs = [];
const BUILT = chalk_1.default.inverse.bold.green(' BUILT ');
const ERROR = chalk_1.default.inverse.bold.red(' ERROR ');
builder.on('start:docs', () => {
    docs.length = 0;
    console.log();
});
builder.on('start:schema', () => {
    schemas.length = 0;
    console.log();
});
builder.on('build:docs', (doc) => {
    docs.push(doc);
});
builder.on('build:schema', (schema) => {
    schemas.push(schema);
});
builder.on('end:docs', () => {
    docs
        .sort(({ documentPath: a }, { documentPath: b }) => a.localeCompare(b))
        .forEach(({ documentPath, definitionPath }) => {
        console.log(`${BUILT} ${chalk_1.default.dim(documentPath)} → ${definitionPath}`);
    });
});
builder.on('end:schema', () => {
    schemas
        .sort(({ schemaPath: a }, { schemaPath: b }) => a.localeCompare(b))
        .forEach(({ schemaPath, schemaTypesPath }) => {
        console.log(`${BUILT} ${chalk_1.default.dim(schemaPath)} → ${schemaTypesPath}`);
    });
});
builder.on('error', (error) => {
    console.log(`${ERROR} ${error.message}`);
    if (error.stack) {
        console.log(chalk_1.default.dim(error.stack));
    }
    console.log();
    if (!argv.watch) {
        process.exit(1);
    }
});
builder.run({ watch: argv.watch });