@smartive/graphql-magic 4.0.0 → 5.0.1

package/dist/cjs/index.cjs

@@ -53,6 +53,7 @@ __export(src_exports, {
   displayField: () => displayField,
   document: () => document,
   enm: () => enm,
+  execute: () => execute,
   fieldType: () => fieldType,
   fields: () => fields,
   generate: () => generate,
@@ -150,6 +151,42 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 
+// src/api/execute.ts
+var import_schema = require("@graphql-tools/schema");
+var import_graphql = require("graphql");
+var execute = async ({
+  additionalResolvers,
+  body,
+  ...ctx
+}) => {
+  const document2 = generate(ctx.rawModels);
+  const generatedResolvers = getResolvers(ctx.models);
+  const schema = (0, import_schema.makeExecutableSchema)({
+    typeDefs: document2,
+    resolvers: {
+      ...generatedResolvers,
+      ...additionalResolvers
+    }
+  });
+  const contextValue = {
+    document: document2,
+    ...ctx
+  };
+  const result = await (0, import_graphql.execute)({
+    schema,
+    document: (0, import_graphql.parse)(new import_graphql.Source(body.query, "GraphQL request")),
+    contextValue,
+    variableValues: body.variables,
+    operationName: body.operationName,
+    fieldResolver: (parent, _args, _ctx, info) => {
+      const node = get(info.fieldNodes, 0);
+      const alias = node.alias;
+      return parent[alias ? alias.value : node.name.value];
+    }
+  });
+  return result;
+};
+
 // src/client/gql.ts
 var gql = (chunks, ...variables) => {
   return chunks.reduce(
@@ -158,10 +195,55 @@ var gql = (chunks, ...variables) => {
   );
 };
 
+// src/client/mutations.ts
+var import_upperCase = __toESM(require("lodash/upperCase"), 1);
+var constantCase = (str) => (0, import_upperCase.default)(str).replace(/ /g, "_");
+var generateMutations = (models) => {
+  const parts = [];
+  for (const { name: name2, creatable, updatable, deletable } of models) {
+    if (creatable) {
+      parts.push(
+        `export const CREATE_${constantCase(
+          name2
+        )} = gql\`
+  mutation Create${name2}Mutation($data: Create${name2}!) {
+    create${name2}(data: $data) { id }
+  }
+\`;`
+      );
+    }
+    if (updatable) {
+      parts.push(
+        `export const UPDATE_${constantCase(
+          name2
+        )} = gql\`
+  mutation Update${name2}Mutation($id: ID!, $data: Update${name2}!) {
+    update${name2}(where: { id: $id }, data: $data) { id }
+  }
+\`;`
+      );
+    }
+    if (deletable) {
+      parts.push(
+        `export const DELETE_${constantCase(
+          name2
+        )} = gql\`
+  mutation Delete${name2}Mutation($id: ID!) {
+    delete${name2}(where: { id: $id })
+  }
+\`;`
+      );
+    }
+  }
+  return `import { gql } from "@smartive/graphql-magic";
+
+${parts.join("\n\n")}`;
+};
+
 // src/client/queries.ts
 var import_upperFirst = __toESM(require("lodash/upperFirst"), 1);
 
-// src/utils.ts
+// src/models/utils.ts
 var import_assert = __toESM(require("assert"), 1);
 var import_inflection = require("inflection");
 var import_camelCase = __toESM(require("lodash/camelCase"), 1);
@@ -620,429 +702,15 @@ var generateKnexTables = (rawModels) => {
   return writer.toString();
 };
 
-// src/generate/generate.ts
-var import_graphql = require("graphql");
-var import_flatMap = __toESM(require("lodash/flatMap"), 1);
-
-// src/generate/utils.ts
-var import_luxon = require("luxon");
-
-// src/values.ts
-var Enum = class {
-  constructor(value2) {
-    this.value = value2;
-  }
-};
-
-// src/generate/utils.ts
-var document = (definitions) => ({
-  kind: "Document",
-  definitions
-});
-var directive = (nme, locations, fields2) => ({
-  name: name(nme),
-  repeatable: false,
-  kind: "DirectiveDefinition",
-  arguments: fields2 && inputValues(fields2),
-  locations: locations.map(name)
-});
-var scalar = (nme) => ({
-  name: name(nme),
-  kind: "ScalarTypeDefinition"
-});
-var input = (nme, fields2, dvs) => ({
-  name: name(nme),
-  fields: inputValues(fields2),
-  kind: "InputObjectTypeDefinition",
-  directives: directives(dvs)
-});
-var object = (nme, fds, interfaces, dvs) => ({
-  name: name(nme),
-  fields: fields(fds),
-  kind: "ObjectTypeDefinition",
-  interfaces: interfaces && interfaces.map((i) => namedType(i)),
-  directives: directives(dvs)
-});
-var iface = (nme, fds, dvs) => ({
-  name: name(nme),
-  fields: fields(fds),
-  kind: "InterfaceTypeDefinition",
-  directives: directives(dvs)
-});
-var inputValues = (fields2) => fields2.map(
-  (field) => ({
-    kind: "InputValueDefinition",
-    name: name(field.name),
-    type: fieldType(field),
-    defaultValue: field.default === void 0 ? void 0 : value(field.default),
-    directives: directives(field.directives)
-  })
-);
-var fields = (fields2) => fields2.map(
-  (field) => ({
-    kind: "FieldDefinition",
-    name: name(field.name),
-    type: fieldType(field),
-    arguments: field.args?.map((arg) => ({
-      kind: "InputValueDefinition",
-      name: name(arg.name),
-      type: fieldType(arg),
-      defaultValue: arg.default === void 0 ? void 0 : value(arg.default)
-    })),
-    directives: directives(field.directives)
-  })
-);
-var inputValue = (nme, type, dvs, description, defaultValue) => ({
-  name: name(nme),
-  type,
-  kind: "InputValueDefinition",
-  directives: directives(dvs),
-  defaultValue: defaultValue ? value(defaultValue) : void 0,
-  description: description ? value(description) : void 0
-});
-var directives = (directives2) => directives2?.map(
-  (directive2) => ({
-    kind: "Directive",
-    name: name(directive2.name),
-    arguments: args(directive2.values)
-  })
-);
-var args = (ags) => ags?.map(
-  (argument) => ({
-    kind: "Argument",
-    name: name(argument.name),
-    value: value(argument.values)
-  })
-);
-var enm = (nme, values) => ({
-  name: name(nme),
-  kind: "EnumTypeDefinition",
-  values: values.map(
-    (v) => ({
-      kind: "EnumValueDefinition",
-      name: name(v)
-    })
-  )
-});
-var nonNull = (type) => ({
-  type,
-  kind: "NonNullType"
-});
-var namedType = (nme) => ({
-  kind: "NamedType",
-  name: name(nme)
-});
-var list = (type) => ({
-  type,
-  kind: "ListType"
-});
-var name = (name2) => ({
-  kind: "Name",
-  value: name2
-});
-var fieldType = (field) => {
-  let type = namedType(field.type);
-  if (field.list) {
-    type = list(nonNull(type));
-  }
-  if (field.nonNull) {
-    type = nonNull(type);
-  }
-  return type;
-};
-var value = (val = null) => val === null ? {
-  kind: "NullValue"
-} : typeof val === "boolean" ? {
-  kind: "BooleanValue",
-  value: val
-} : typeof val === "number" ? {
-  kind: "IntValue",
-  value: `${val}`
-} : typeof val === "string" ? {
-  kind: "StringValue",
-  value: val
-} : val instanceof Enum ? {
-  kind: "EnumValue",
-  value: val.value
-} : Array.isArray(val) ? {
-  kind: "ListValue",
-  values: val.map(value)
-} : val instanceof import_luxon.DateTime ? {
-  kind: "StringValue",
-  value: val.toString()
-} : {
-  kind: "ObjectValue",
-  fields: Object.keys(val).map(
-    (nme) => ({
-      kind: "ObjectField",
-      name: name(nme),
-      value: value(val[nme])
-    })
-  )
-};
-
-// src/generate/generate.ts
-var generateDefinitions = (rawModels) => {
-  const models = getModels(rawModels);
-  return [
-    // Predefined types
-    enm("Order", ["ASC", "DESC"]),
-    scalar("DateTime"),
-    scalar("Upload"),
-    ...rawModels.filter(isEnumModel).map((model) => enm(model.name, model.values)),
-    ...rawModels.filter(isRawEnumModel).map((model) => enm(model.name, model.values)),
-    ...rawModels.filter(isScalarModel).map((model) => scalar(model.name)),
-    ...rawModels.filter(isRawObjectModel).map((model) => object(model.name, model.fields)),
-    ...(0, import_flatMap.default)(
-      models.map((model) => {
-        const types = [
-          object(
-            model.name,
-            [
-              ...model.fields.filter(isQueriableField).map((field) => ({
-                ...field,
-                type: field.type === "relation" || field.type === "enum" || field.type === "raw" ? field.typeName : field.type,
-                args: [...field.args || []],
-                directives: field.directives
-              })),
-              ...model.reverseRelations.map(({ name: name2, field, model: model2 }) => ({
-                name: name2,
-                type: model2.name,
-                list: !field.toOne,
-                nonNull: !field.toOne,
-                args: [
-                  { name: "where", type: `${model2.name}Where` },
-                  ...model2.fields.some(({ searchable }) => searchable) ? [{ name: "search", type: "String" }] : [],
-                  ...model2.fields.some(({ orderable }) => orderable) ? [{ name: "orderBy", type: `${model2.name}OrderBy`, list: true }] : [],
-                  { name: "limit", type: "Int" },
-                  { name: "offset", type: "Int" }
-                ]
-              }))
-            ],
-            model.interfaces
-          ),
-          input(`${model.name}Where`, [
-            ...model.fields.filter(({ type, unique, filterable }) => (unique || filterable) && type !== "relation").map(({ type, name: name2, filterable }) => ({
-              name: name2,
-              type,
-              list: true,
-              default: typeof filterable === "object" ? filterable.default : void 0
-            })),
-            ...(0, import_flatMap.default)(
-              model.fields.filter(({ comparable }) => comparable),
-              ({ name: name2, type }) => [
-                { name: `${name2}_GT`, type },
-                { name: `${name2}_GTE`, type },
-                { name: `${name2}_LT`, type },
-                { name: `${name2}_LTE`, type }
-              ]
-            ),
-            ...model.fields.filter(isRelation).filter(({ filterable }) => filterable).map(({ name: name2, typeName }) => ({
-              name: name2,
-              type: `${typeName}Where`
-            }))
-          ]),
-          input(
-            `${model.name}WhereUnique`,
-            model.fields.filter(({ unique }) => unique).map(({ name: name2, type }) => ({ name: name2, type }))
-          ),
-          ...model.fields.some(({ orderable }) => orderable) ? [
-            input(
-              `${model.name}OrderBy`,
-              model.fields.filter(({ orderable }) => orderable).map(({ name: name2 }) => ({ name: name2, type: "Order" }))
-            )
-          ] : []
-        ];
-        if (model.creatable) {
-          types.push(
-            input(
-              `Create${model.name}`,
-              model.fields.filter(({ creatable }) => creatable).map(
-                ({ name: name2, nonNull: nonNull2, list: list2, default: defaultValue, ...field }) => field.type === "relation" ? { name: `${name2}Id`, type: "ID", nonNull: nonNull2 } : { name: name2, type: field.type, list: list2, nonNull: nonNull2 && defaultValue === void 0 }
-              )
-            )
-          );
-        }
-        if (model.updatable) {
-          types.push(
-            input(
-              `Update${model.name}`,
-              model.fields.filter(({ updatable }) => updatable).map(
-                ({ name: name2, type, list: list2 }) => type === "relation" ? { name: `${name2}Id`, type: "ID" } : { name: name2, type, list: list2 }
-              )
-            )
-          );
-        }
-        return types;
-      })
-    ),
-    object("Query", [
-      {
-        name: "me",
-        type: "User"
-      },
-      ...models.filter(({ queriable }) => queriable).map(({ name: name2 }) => ({
-        name: typeToField(name2),
-        type: name2,
-        nonNull: true,
-        args: [
-          {
-            name: "where",
-            type: `${name2}WhereUnique`,
-            nonNull: true
-          }
-        ]
-      })),
-      ...models.filter(({ listQueriable }) => listQueriable).map((model) => ({
-        name: getModelPluralField(model),
-        type: model.name,
-        list: true,
-        nonNull: true,
-        args: [
-          { name: "where", type: `${model.name}Where` },
-          ...model.fields.some(({ searchable }) => searchable) ? [{ name: "search", type: "String" }] : [],
-          ...model.fields.some(({ orderable }) => orderable) ? [{ name: "orderBy", type: `${model.name}OrderBy`, list: true }] : [],
-          { name: "limit", type: "Int" },
-          { name: "offset", type: "Int" }
-        ]
-      }))
-    ]),
-    object("Mutation", [
-      ...(0, import_flatMap.default)(
-        models.map((model) => {
-          const mutations = [];
-          if (model.creatable) {
-            mutations.push({
-              name: `create${model.name}`,
-              type: model.name,
-              nonNull: true,
-              args: [
-                {
-                  name: "data",
-                  type: `Create${model.name}`,
-                  nonNull: true
-                }
-              ]
-            });
-          }
-          if (model.updatable) {
-            mutations.push({
-              name: `update${model.name}`,
-              type: model.name,
-              nonNull: true,
-              args: [
-                {
-                  name: "where",
-                  type: `${model.name}WhereUnique`,
-                  nonNull: true
-                },
-                {
-                  name: "data",
-                  type: `Update${model.name}`,
-                  nonNull: true
-                }
-              ]
-            });
-          }
-          if (model.deletable) {
-            mutations.push({
-              name: `delete${model.name}`,
-              type: "ID",
-              nonNull: true,
-              args: [
-                {
-                  name: "where",
-                  type: `${model.name}WhereUnique`,
-                  nonNull: true
-                },
-                {
-                  name: "dryRun",
-                  type: "Boolean"
-                }
-              ]
-            });
-            mutations.push({
-              name: `restore${model.name}`,
-              type: "ID",
-              nonNull: true,
-              args: [
-                {
-                  name: "where",
-                  type: `${model.name}WhereUnique`,
-                  nonNull: true
-                }
-              ]
-            });
-          }
-          return mutations;
-        })
-      )
-    ])
-  ];
-};
-var generate = (rawModels) => document(generateDefinitions(rawModels));
-var printSchema = (schema) => [
-  ...schema.getDirectives().map((d) => d.astNode && (0, import_graphql.print)(d.astNode)),
-  ...Object.values(schema.getTypeMap()).filter((t) => !t.name.match(/^__/)).sort((a, b) => a.name > b.name ? 1 : -1).map((t) => t.astNode && (0, import_graphql.print)(t.astNode))
-].filter(Boolean).map((s) => `${s}
-`).join("\n");
-var printSchemaFromDocument = (document2) => printSchema((0, import_graphql.buildASTSchema)(document2));
-var printSchemaFromModels = (models) => printSchema((0, import_graphql.buildASTSchema)(generate(models)));
-
-// src/generate/mutations.ts
-var import_upperCase = __toESM(require("lodash/upperCase"), 1);
-var constantCase = (str) => (0, import_upperCase.default)(str).replace(/ /g, "_");
-var generateMutations = (models) => {
-  const parts = [];
-  for (const { name: name2, creatable, updatable, deletable } of models) {
-    if (creatable) {
-      parts.push(
-        `export const CREATE_${constantCase(
-          name2
-        )} = gql\`
-  mutation Create${name2}Mutation($data: Create${name2}!) {
-    create${name2}(data: $data) { id }
-  }
-\`;`
-      );
-    }
-    if (updatable) {
-      parts.push(
-        `export const UPDATE_${constantCase(
-          name2
-        )} = gql\`
-  mutation Update${name2}Mutation($id: ID!, $data: Update${name2}!) {
-    update${name2}(where: { id: $id }, data: $data) { id }
-  }
-\`;`
-      );
-    }
-    if (deletable) {
-      parts.push(
-        `export const DELETE_${constantCase(
-          name2
-        )} = gql\`
-  mutation Delete${name2}Mutation($id: ID!) {
-    delete${name2}(where: { id: $id })
-  }
-\`;`
-      );
-    }
-  }
-  return `import { gql } from "@smartive/graphql-magic";
-
-${parts.join("\n\n")}`;
-};
-
-// src/migrations/generate.ts
-var import_code_block_writer2 = __toESM(require("code-block-writer"), 1);
-var import_knex_schema_inspector = require("knex-schema-inspector");
-var import_lowerFirst = __toESM(require("lodash/lowerFirst"), 1);
-var MigrationGenerator = class {
-  constructor(knex, rawModels) {
-    this.rawModels = rawModels;
-    this.schema = (0, import_knex_schema_inspector.SchemaInspector)(knex);
-    this.models = getModels(rawModels);
+// src/migrations/generate.ts
+var import_code_block_writer2 = __toESM(require("code-block-writer"), 1);
+var import_knex_schema_inspector = require("knex-schema-inspector");
+var import_lowerFirst = __toESM(require("lodash/lowerFirst"), 1);
+var MigrationGenerator = class {
+  constructor(knex, rawModels) {
+    this.rawModels = rawModels;
+    this.schema = (0, import_knex_schema_inspector.SchemaInspector)(knex);
+    this.models = getModels(rawModels);
   }
   writer = new import_code_block_writer2.default["default"]({
     useSingleQuote: true,
@@ -2132,7 +1800,7 @@ var import_uuid = require("uuid");
 
 // src/resolvers/resolver.ts
 var import_cloneDeep = __toESM(require("lodash/cloneDeep"), 1);
-var import_flatMap2 = __toESM(require("lodash/flatMap"), 1);
+var import_flatMap = __toESM(require("lodash/flatMap"), 1);
 
 // src/resolvers/node.ts
 var getResolverNode = ({
@@ -2376,7 +2044,7 @@ var applySubQueries = async (node, entries, parentVerifiedPermissionStacks) => {
     }
     await applySubQueries(
       subNode,
-      (0, import_flatMap2.default)(
+      (0, import_flatMap.default)(
         entries.map((entry) => {
           const children2 = entry[fieldName];
           return isList ? children2 : children2 ? [children2] : [];
@@ -2676,6 +2344,375 @@ var getResolvers = (models) => ({
     }))
   ])
 });
+
+// src/schema/generate.ts
+var import_graphql5 = require("graphql");
+var import_flatMap2 = __toESM(require("lodash/flatMap"), 1);
+
+// src/schema/utils.ts
+var import_luxon = require("luxon");
+
+// src/values.ts
+var Enum = class {
+  constructor(value2) {
+    this.value = value2;
+  }
+};
+
+// src/schema/utils.ts
+var document = (definitions) => ({
+  kind: "Document",
+  definitions
+});
+var directive = (nme, locations, fields2) => ({
+  name: name(nme),
+  repeatable: false,
+  kind: "DirectiveDefinition",
+  arguments: fields2 && inputValues(fields2),
+  locations: locations.map(name)
+});
+var scalar = (nme) => ({
+  name: name(nme),
+  kind: "ScalarTypeDefinition"
+});
+var input = (nme, fields2, dvs) => ({
+  name: name(nme),
+  fields: inputValues(fields2),
+  kind: "InputObjectTypeDefinition",
+  directives: directives(dvs)
+});
+var object = (nme, fds, interfaces, dvs) => ({
+  name: name(nme),
+  fields: fields(fds),
+  kind: "ObjectTypeDefinition",
+  interfaces: interfaces && interfaces.map((i) => namedType(i)),
+  directives: directives(dvs)
+});
+var iface = (nme, fds, dvs) => ({
+  name: name(nme),
+  fields: fields(fds),
+  kind: "InterfaceTypeDefinition",
+  directives: directives(dvs)
+});
+var inputValues = (fields2) => fields2.map(
+  (field) => ({
+    kind: "InputValueDefinition",
+    name: name(field.name),
+    type: fieldType(field),
+    defaultValue: field.default === void 0 ? void 0 : value(field.default),
+    directives: directives(field.directives)
+  })
+);
+var fields = (fields2) => fields2.map(
+  (field) => ({
+    kind: "FieldDefinition",
+    name: name(field.name),
+    type: fieldType(field),
+    arguments: field.args?.map((arg) => ({
+      kind: "InputValueDefinition",
+      name: name(arg.name),
+      type: fieldType(arg),
+      defaultValue: arg.default === void 0 ? void 0 : value(arg.default)
+    })),
+    directives: directives(field.directives)
+  })
+);
+var inputValue = (nme, type, dvs, description, defaultValue) => ({
+  name: name(nme),
+  type,
+  kind: "InputValueDefinition",
+  directives: directives(dvs),
+  defaultValue: defaultValue ? value(defaultValue) : void 0,
+  description: description ? value(description) : void 0
+});
+var directives = (directives2) => directives2?.map(
+  (directive2) => ({
+    kind: "Directive",
+    name: name(directive2.name),
+    arguments: args(directive2.values)
+  })
+);
+var args = (ags) => ags?.map(
+  (argument) => ({
+    kind: "Argument",
+    name: name(argument.name),
+    value: value(argument.values)
+  })
+);
+var enm = (nme, values) => ({
+  name: name(nme),
+  kind: "EnumTypeDefinition",
+  values: values.map(
+    (v) => ({
+      kind: "EnumValueDefinition",
+      name: name(v)
+    })
+  )
+});
+var nonNull = (type) => ({
+  type,
+  kind: "NonNullType"
+});
+var namedType = (nme) => ({
+  kind: "NamedType",
+  name: name(nme)
+});
+var list = (type) => ({
+  type,
+  kind: "ListType"
+});
+var name = (name2) => ({
+  kind: "Name",
+  value: name2
+});
+var fieldType = (field) => {
+  let type = namedType(field.type);
+  if (field.list) {
+    type = list(nonNull(type));
+  }
+  if (field.nonNull) {
+    type = nonNull(type);
+  }
+  return type;
+};
+var value = (val = null) => val === null ? {
+  kind: "NullValue"
+} : typeof val === "boolean" ? {
+  kind: "BooleanValue",
+  value: val
+} : typeof val === "number" ? {
+  kind: "IntValue",
+  value: `${val}`
+} : typeof val === "string" ? {
+  kind: "StringValue",
+  value: val
+} : val instanceof Enum ? {
+  kind: "EnumValue",
+  value: val.value
+} : Array.isArray(val) ? {
+  kind: "ListValue",
+  values: val.map(value)
+} : val instanceof import_luxon.DateTime ? {
+  kind: "StringValue",
+  value: val.toString()
+} : {
+  kind: "ObjectValue",
+  fields: Object.keys(val).map(
+    (nme) => ({
+      kind: "ObjectField",
+      name: name(nme),
+      value: value(val[nme])
+    })
+  )
+};
+
+// src/schema/generate.ts
+var generateDefinitions = (rawModels) => {
+  const models = getModels(rawModels);
+  return [
+    // Predefined types
+    enm("Order", ["ASC", "DESC"]),
+    scalar("DateTime"),
+    scalar("Upload"),
+    ...rawModels.filter(isEnumModel).map((model) => enm(model.name, model.values)),
+    ...rawModels.filter(isRawEnumModel).map((model) => enm(model.name, model.values)),
+    ...rawModels.filter(isScalarModel).map((model) => scalar(model.name)),
+    ...rawModels.filter(isRawObjectModel).map((model) => object(model.name, model.fields)),
+    ...(0, import_flatMap2.default)(
+      models.map((model) => {
+        const types = [
+          object(
+            model.name,
+            [
+              ...model.fields.filter(isQueriableField).map((field) => ({
+                ...field,
+                type: field.type === "relation" || field.type === "enum" || field.type === "raw" ? field.typeName : field.type,
+                args: [...field.args || []],
+                directives: field.directives
+              })),
+              ...model.reverseRelations.map(({ name: name2, field, model: model2 }) => ({
+                name: name2,
+                type: model2.name,
+                list: !field.toOne,
+                nonNull: !field.toOne,
+                args: [
+                  { name: "where", type: `${model2.name}Where` },
+                  ...model2.fields.some(({ searchable }) => searchable) ? [{ name: "search", type: "String" }] : [],
+                  ...model2.fields.some(({ orderable }) => orderable) ? [{ name: "orderBy", type: `${model2.name}OrderBy`, list: true }] : [],
+                  { name: "limit", type: "Int" },
+                  { name: "offset", type: "Int" }
+                ]
+              }))
+            ],
+            model.interfaces
+          ),
+          input(`${model.name}Where`, [
+            ...model.fields.filter(({ type, unique, filterable }) => (unique || filterable) && type !== "relation").map(({ type, name: name2, filterable }) => ({
+              name: name2,
+              type,
+              list: true,
+              default: typeof filterable === "object" ? filterable.default : void 0
+            })),
+            ...(0, import_flatMap2.default)(
+              model.fields.filter(({ comparable }) => comparable),
+              ({ name: name2, type }) => [
+                { name: `${name2}_GT`, type },
+                { name: `${name2}_GTE`, type },
+                { name: `${name2}_LT`, type },
+                { name: `${name2}_LTE`, type }
+              ]
+            ),
+            ...model.fields.filter(isRelation).filter(({ filterable }) => filterable).map(({ name: name2, typeName }) => ({
+              name: name2,
+              type: `${typeName}Where`
+            }))
+          ]),
+          input(
+            `${model.name}WhereUnique`,
+            model.fields.filter(({ unique }) => unique).map(({ name: name2, type }) => ({ name: name2, type }))
+          ),
+          ...model.fields.some(({ orderable }) => orderable) ? [
+            input(
+              `${model.name}OrderBy`,
+              model.fields.filter(({ orderable }) => orderable).map(({ name: name2 }) => ({ name: name2, type: "Order" }))
+            )
+          ] : []
+        ];
+        if (model.creatable) {
+          types.push(
+            input(
+              `Create${model.name}`,
+              model.fields.filter(({ creatable }) => creatable).map(
+                ({ name: name2, nonNull: nonNull2, list: list2, default: defaultValue, ...field }) => field.type === "relation" ? { name: `${name2}Id`, type: "ID", nonNull: nonNull2 } : { name: name2, type: field.type, list: list2, nonNull: nonNull2 && defaultValue === void 0 }
+              )
+            )
+          );
+        }
+        if (model.updatable) {
+          types.push(
+            input(
+              `Update${model.name}`,
+              model.fields.filter(({ updatable }) => updatable).map(
+                ({ name: name2, type, list: list2 }) => type === "relation" ? { name: `${name2}Id`, type: "ID" } : { name: name2, type, list: list2 }
+              )
+            )
+          );
+        }
+        return types;
+      })
+    ),
+    object("Query", [
+      {
+        name: "me",
+        type: "User"
+      },
+      ...models.filter(({ queriable }) => queriable).map(({ name: name2 }) => ({
+        name: typeToField(name2),
+        type: name2,
+        nonNull: true,
+        args: [
+          {
+            name: "where",
+            type: `${name2}WhereUnique`,
+            nonNull: true
+          }
+        ]
+      })),
+      ...models.filter(({ listQueriable }) => listQueriable).map((model) => ({
+        name: getModelPluralField(model),
+        type: model.name,
+        list: true,
+        nonNull: true,
+        args: [
+          { name: "where", type: `${model.name}Where` },
+          ...model.fields.some(({ searchable }) => searchable) ? [{ name: "search", type: "String" }] : [],
+          ...model.fields.some(({ orderable }) => orderable) ? [{ name: "orderBy", type: `${model.name}OrderBy`, list: true }] : [],
+          { name: "limit", type: "Int" },
+          { name: "offset", type: "Int" }
+        ]
+      }))
+    ]),
+    object("Mutation", [
+      ...(0, import_flatMap2.default)(
+        models.map((model) => {
+          const mutations = [];
+          if (model.creatable) {
+            mutations.push({
+              name: `create${model.name}`,
+              type: model.name,
+              nonNull: true,
+              args: [
+                {
+                  name: "data",
+                  type: `Create${model.name}`,
+                  nonNull: true
+                }
+              ]
+            });
+          }
+          if (model.updatable) {
+            mutations.push({
+              name: `update${model.name}`,
+              type: model.name,
+              nonNull: true,
+              args: [
+                {
+                  name: "where",
+                  type: `${model.name}WhereUnique`,
+                  nonNull: true
+                },
+                {
+                  name: "data",
+                  type: `Update${model.name}`,
+                  nonNull: true
+                }
+              ]
+            });
+          }
+          if (model.deletable) {
+            mutations.push({
+              name: `delete${model.name}`,
+              type: "ID",
+              nonNull: true,
+              args: [
+                {
+                  name: "where",
+                  type: `${model.name}WhereUnique`,
+                  nonNull: true
+                },
+                {
+                  name: "dryRun",
+                  type: "Boolean"
+                }
+              ]
+            });
+            mutations.push({
+              name: `restore${model.name}`,
+              type: "ID",
+              nonNull: true,
+              args: [
+                {
+                  name: "where",
+                  type: `${model.name}WhereUnique`,
+                  nonNull: true
+                }
+              ]
+            });
+          }
+          return mutations;
+        })
+      )
+    ])
+  ];
+};
+var generate = (rawModels) => document(generateDefinitions(rawModels));
+var printSchema = (schema) => [
+  ...schema.getDirectives().map((d) => d.astNode && (0, import_graphql5.print)(d.astNode)),
+  ...Object.values(schema.getTypeMap()).filter((t) => !t.name.match(/^__/)).sort((a, b) => a.name > b.name ? 1 : -1).map((t) => t.astNode && (0, import_graphql5.print)(t.astNode))
+].filter(Boolean).map((s) => `${s}
+`).join("\n");
+var printSchemaFromDocument = (document2) => printSchema((0, import_graphql5.buildASTSchema)(document2));
+var printSchemaFromModels = (models) => printSchema((0, import_graphql5.buildASTSchema)(generate(models)));
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AliasGenerator,
@@ -2702,6 +2739,7 @@ var getResolvers = (models) => ({
   displayField,
   document,
   enm,
+  execute,
   fieldType,
   fields,
   generate,