schickling

nexus-prisma-generate

var prisma_generate_schema_1 = require("prisma-generate-schema");

var cli = meow("\n    nexus-prisma-generate prisma-client-dir output\n\n    > Generate the TypeScript types for nexus-prisma\n\n    -----\n    \n    Inputs should be relative to the root of your project\n\n    --client (required): Path to your prisma-client directory (eg: ./generated/prisma-client/)\n    --output (required): Path to directory where you want to output the typings (eg: ./generated/nexus-prisma)\n    --js     (optional): Whether to generate the types for Javascript\n", {

    var _a = cli.flags, prismaClientDir = _a.client, output = _a.output, jsMode = _a.js;

        console.log('ERROR: Missing argument --client');

        console.log('ERROR: Missing argument --output');

    var rootPath = config_1.findRootDirectory();

    var resolvedOutput = output.startsWith('/')

    var resolvedPrismaClientDir = prismaClientDir.startsWith('/')

        : path_1.join(rootPath, prismaClientDir);

    if (!fs_1.existsSync(resolvedPrismaClientDir)) {

        console.log("ERROR: Cannot find --client path at " + resolvedPrismaClientDir);

    // Create the output directories if needed (mkdir -p)

    fs_1.mkdirSync(resolvedOutput, { recursive: true });

    var _b = config_1.findDatamodelAndComputeSchema(), datamodel = _b.datamodel, databaseType = _b.databaseType;

        var schema = prisma_generate_schema_1.generateCRUDSchemaFromInternalISDL(datamodel, databaseType);

        var renderedDatamodel = renderDatamodel(datamodel, schema);

        var nexusPrismaTypesPath = path_1.join(rootPath, output, 'nexus-prisma.ts');

        var nexusPrismaTypes = renderNexusPrismaTypes(schema, config_1.getImportPathRelativeToOutput(resolvedPrismaClientDir, nexusPrismaTypesPath));

        fs_1.writeFileSync(nexusPrismaTypesPath, nexusPrismaTypes);

            var datamodelPath = path_1.join(rootPath, output, 'meta-schema.js');

            var datamodelPath = path_1.join(rootPath, output, 'datamodel-info.js');

            var indexPath = path_1.join(rootPath, output, 'index.js');

            fs_1.writeFileSync(datamodelPath, "module.exports = " + renderedDatamodel);

            fs_1.writeFileSync(indexPath, renderIndexJs());

            var datamodelPath = path_1.join(rootPath, output, 'meta-schema.ts');

            var datamodelPath = path_1.join(rootPath, output, 'datamodel-info.ts');

            var indexPath = path_1.join(rootPath, output, 'index.ts');

            fs_1.writeFileSync(datamodelPath, "export default " + renderedDatamodel);

            fs_1.writeFileSync(indexPath, "export { default } from './meta-schema'");

            fs_1.writeFileSync(indexPath, "export { default } from './datamodel-info'");

        console.log("Types generated at " + output);

    return "const metaSchema = require('./meta-schema')\n  \nmodule.exports = metaSchema\n  ";

    return "const datamodelInfo = require('./datamodel-info')\n  \nmodule.exports = datamodelInfo\n  ";

function renderDatamodel(datamodel, schema) {

    return "{\n  uniqueFieldsByModel: {\n" + datamodel.types

        return "    " + type.name + ": [" + type.fields

            .filter(function (field) { return field.isUnique; })

            .map(function (field) { return "'" + field.name + "'"; })

        .join(',' + os_1.EOL) + "\n  },\n  schema: " + JSON.stringify(graphql_1.introspectionFromSchema(schema), null, 2) + "\n}\n  ";

function renderNexusPrismaTypes(schema, prismaClientPath) {

    var types = Object.values(schema.getTypeMap());

    var objectTypes = types.filter(function (t) { return graphql_1.isObjectType(t) && !t.name.startsWith('__'); });

    var inputTypes = types.filter(graphql_1.isInputObjectType);

    var enumTypes = types.filter(function (t) { return graphql_1.isEnumType(t) && !t.name.startsWith('__'); });

    return "// GENERATED TYPES FOR NEXUS-PRISMA. /!\\ DO NOT EDIT MANUALLY\n\nimport { core } from 'nexus'\nimport { GraphQLResolveInfo } from 'graphql'\nimport * as prisma from '" + prismaClientPath + "'\n\ndeclare global {\n  interface NexusPrismaGen extends NexusPrismaTypes {}\n}\n\nexport interface NexusPrismaTypes {\n  objectTypes: {\n    fields: {\n" + objectTypes

        .map(function (type) { return "      " + type.name + ": " + getObjectTypeFieldsName(type); })

        .join(os_1.EOL) + "\n    }\n    fieldsDetails: {\n" + objectTypes

        .map(function (type) { return "      " + type.name + ": " + getObjectTypeFieldsDetailsName(type); })

        .join(os_1.EOL) + "\n    }\n  }\n  inputTypes: {\n    fields: {\n" + inputTypes

        return "      " + getInputObjectTypeName(type) + ": " + getInputObjectTypeFieldsName(type);

        .join(os_1.EOL) + "\n    }\n  }\n  enumTypes: {\n" + enumTypes

        .map(function (type) { return "    " + type.name + ": " + getEnumTypeName(type) + ","; })

        .join(os_1.EOL) + "\n  }\n}\n\n" + objectTypes.map(renderObjectType).join(os_1.EOL) + "\n\n" + inputTypes.map(renderInputType).join(os_1.EOL) + "\n\n" + enumTypes.map(renderEnumType).join(os_1.EOL) + "\n  ";

    var fields = Object.values(type.getFields());

    return "// Types for " + type.name + "\n\n" + renderFields(type, fields) + "\n\n" + renderFieldsArgs(type, fields) + "\n\n" + renderTypeFieldDetails(type, fields) + "\n";

function renderTypeFieldDetails(type, fields) {

    return "export interface " + getObjectTypeFieldsDetailsName(type) + " {\n" + fields

        .map(function (field) { return "  " + field.name + ": {\n    type: '" + graphql_2.getTypeName(field.type) + "'\n    args: " + (field.args.length > 0

        ? "Record<" + getTypeFieldArgName(type, field) + ", core.NexusArgDef<string>>"

        : '{}') + "\n    description: string\n    list: " + (graphql_2.isList(field.type) ? true : undefined) + "\n    nullable: " + !graphql_2.isRequired(field.type) + "\n    resolve: " + (graphql_1.isScalarType(graphql_2.getFinalType(field.type))

        : "(\n      root: core.RootValue<\"" + type.name + "\">,\n      args: " + renderResolverArgs(field) + ",\n      context: core.GetGen<\"context\">,\n      info?: GraphQLResolveInfo\n    ) => " + renderResolverReturnType(field)) + "\n  }"; })

        .map(function (arg) { return "" + arg.name + (graphql_2.isRequired(arg.type) ? '' : '?') + ": " + getTSType(arg); })

    return "type " + getObjectTypeFieldsName(type) + " =\n  | " + getExposableFieldsTypeName(type) + "\n" + fields

        return "  | { name: '" + f.name + "', args?: " + (f.args.length > 0

            ? getTypeFieldArgName(type, f) + "[] | false"

            : '[] | false') + ", alias?: string  } ";

        .join(os_1.EOL) + "\n\ntype " + getExposableFieldsTypeName(type) + " =\n" + fields.map(function (f) { return "  | '" + f.name + "'"; }).join(os_1.EOL) + "\n";

function renderFieldsArgs(type, fields) {

        .filter(function (field) { return field.args.length > 0; })

        .map(function (field) { return renderFieldArg(type, field); })

    return "type " + getTypeFieldArgName(type, field) + " =\n" + field.args.map(function (arg) { return "  | '" + arg.name + "'"; }).join(os_1.EOL);

    var finalType = graphql_2.getFinalType(graphqlType.type);

    if (graphql_1.isScalarType(finalType)) {

        returnType = graphqlToTypescript[graphql_2.getTypeName(finalType)];

    else if (graphql_1.isInputObjectType(finalType)) {

        returnType = getInputObjectTypeName(finalType);

        returnType = "prisma." + graphql_2.getTypeName(finalType);

    if (graphql_2.isList(graphqlType.type)) {

    if (!graphql_2.isRequired(graphqlType.type)) {

function renderResolverReturnType(field) {

    return "Promise<" + returnType + "> | " + returnType;

    var fields = Object.values(input.getFields());

    return "export interface " + getInputObjectTypeName(input) + " {\n" + fields

        return "  " + field.name + (graphql_2.isRequired(input) ? '' : '?') + ": " + getTSType(field);

    "nexus-prisma-generate": "dist/index.js"

    "url": "git+https://github.com/prisma/nexus-prisma-plugin.git"

    "url": "https://github.com/prisma/nexus-prisma-plugin/issues"

  "homepage": "https://github.com/prisma/nexus-prisma-plugin#readme",

    "prepublish": "rm -rf example/node_modules && npm run build",

    "graphql": "^0.12.0 || ^0.13.0 || ^14.0.0",

    "prisma-datamodel": "1.28.0-alpha.8",

    "prisma-generate-schema": "1.28.0-alpha.8"

		{
		"name": "nexus-prisma-generate",
		"version": "0.2.1",
		"version": "0.3.0",
		"typings": "dist/index.d.ts",
		@@ -5,0 +5,0 @@ "license": "MIT",

		@@ -58,3 +58,3 @@ #!/usr/bin/env node
		if (jsMode) {
		var datamodelPath = path_1.join(rootPath, output, 'meta-schema.js');
		var datamodelPath = path_1.join(rootPath, output, 'datamodel-info.js');
		var indexPath = path_1.join(rootPath, output, 'index.js');
		@@ -65,6 +65,6 @@ fs_1.writeFileSync(datamodelPath, "module.exports = " + renderedDatamodel);
		else {
		var datamodelPath = path_1.join(rootPath, output, 'meta-schema.ts');
		var datamodelPath = path_1.join(rootPath, output, 'datamodel-info.ts');
		var indexPath = path_1.join(rootPath, output, 'index.ts');
		fs_1.writeFileSync(datamodelPath, "export default " + renderedDatamodel);
		fs_1.writeFileSync(indexPath, "export { default } from './meta-schema'");
		fs_1.writeFileSync(indexPath, "export { default } from './datamodel-info'");
		}
		@@ -78,3 +78,3 @@ console.log("Types generated at " + output);
		function renderIndexJs() {
		return "const metaSchema = require('./meta-schema')\n \nmodule.exports = metaSchema\n ";
		return "const datamodelInfo = require('./datamodel-info')\n \nmodule.exports = datamodelInfo\n ";
		}
		@@ -81,0 +81,0 @@ function renderDatamodel(datamodel, schema) {

Improved metrics