@smartive/graphql-magic 14.1.0 → 15.0.1

package/.env

@@ -1,4 +1,4 @@
 DATABASE_HOST=localhost
 DATABASE_NAME=postgres
 DATABASE_USER=postgres
-DATABAE_PASSWORD=password
+DATABASE_PASSWORD=password

package/CHANGELOG.md

@@ -1,6 +1,6 @@
-# [14.1.0](https://github.com/smartive/graphql-magic/compare/v14.0.2...v14.1.0) (2024-03-04)
+## [15.0.1](https://github.com/smartive/graphql-magic/compare/v15.0.0...v15.0.1) (2024-04-03)
 
 
-### Features
+### Bug Fixes
 
-* Add display to relation ([#143](https://github.com/smartive/graphql-magic/issues/143)) ([58e3bf8](https://github.com/smartive/graphql-magic/commit/58e3bf80ea9be367a20b4a5a7129a68c21e2e75a))
+* Stuff ([#152](https://github.com/smartive/graphql-magic/issues/152)) ([be06252](https://github.com/smartive/graphql-magic/commit/be0625222485da5ddb22b0d9feaf3ac7fdccd1a6))

package/README.md

@@ -2,42 +2,7 @@
 
 Welcome to graphql-magic!
 
-## Usage
-
-### Prerequisites
-
-* Next.js
-* TypeScript
-* Knex.js
-* Postgresql
-
-### Setup
-
-Dependencies:
-
-```
-npm i @smartive/graphql-magic
-```
-
-Setup:
-
-```
-npx gqm setup
-```
-
-Generate all the things:
-
-```
-npx gqm generate
-```
-
-Generate a migration:
-
-```
-npx gqm generate-migration
-```
-
-To be continued...
+See the [docs](https://)
 
 ## Development
 

package/dist/bin/gqm.cjs

@@ -1343,7 +1343,7 @@ var generateDefinitions = ({
   entities,
   objects
 }) => {
-  return [
+  const definitions = [
     // Predefined types
     ...rawEnums.map((model) => enm(model.name, model.values)),
     ...enums.map((model) => enm(model.name, model.values)),
@@ -1487,80 +1487,84 @@ var generateDefinitions = ({
         ]
       })),
       ...objects.filter((model) => model.name === "Query").flatMap((model) => model.fields)
-    ]),
-    object("Mutation", [
-      ...entities.flatMap((model) => {
-        const mutations = [];
-        if (!isRootModel(model)) {
-          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;
-      }),
-      ...objects.filter((model) => model.name === "Mutation").flatMap((model) => model.fields)
     ])
   ];
+  const mutations = [
+    ...entities.flatMap((model) => {
+      const mutations2 = [];
+      if (!isRootModel(model)) {
+        if (model.creatable) {
+          mutations2.push({
+            name: `create${model.name}`,
+            type: model.name,
+            nonNull: true,
+            args: [
+              {
+                name: "data",
+                type: `Create${model.name}`,
+                nonNull: true
+              }
+            ]
+          });
+        }
+        if (model.updatable) {
+          mutations2.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) {
+          mutations2.push({
+            name: `delete${model.name}`,
+            type: "ID",
+            nonNull: true,
+            args: [
+              {
+                name: "where",
+                type: `${model.name}WhereUnique`,
+                nonNull: true
+              },
+              {
+                name: "dryRun",
+                type: "Boolean"
+              }
+            ]
+          });
+          mutations2.push({
+            name: `restore${model.name}`,
+            type: "ID",
+            nonNull: true,
+            args: [
+              {
+                name: "where",
+                type: `${model.name}WhereUnique`,
+                nonNull: true
+              }
+            ]
+          });
+        }
+      }
+      return mutations2;
+    }),
+    ...objects.filter((model) => model.name === "Mutation").flatMap((model) => model.fields)
+  ];
+  if (mutations.length) {
+    definitions.push(object("Mutation", mutations));
+  }
+  return definitions;
 };
 var generate = (models) => document(generateDefinitions(models));
 var printSchema = (schema) => [
@@ -1593,10 +1597,14 @@ var readLine = (prompt) => {
 };
 
 // src/bin/gqm/templates.ts
-var EMPTY_MODELS = `
-import { RawModels, Models } from '@smartive/graphql-magic';
+var GITIGNORE = (path) => `
+# graphql-magic
+${path}/**/*
+${path}/**/.gitkeep
+`;
+var EMPTY_MODELS = `import { ModelDefinitions, Models } from '@smartive/graphql-magic';
 
-const rawModels: RawModels = [
+const modelDefinitions: ModelDefinitions = [
   {
     kind: 'entity',
     name: 'User',
@@ -1604,10 +1612,9 @@ const rawModels: RawModels = [
   },
 ]
 
-export const models = new Models(rawModels);
+export const models = new Models(modelDefinitions);
 `;
-var KNEXFILE = `
-import { DateTime } from 'luxon';
+var KNEXFILE = `import { DateTime } from 'luxon';
 import { types } from 'pg';
 
 const dateOids = { date: 1082, timestamptz: 1184, timestamp: 1114 };
@@ -1620,7 +1627,7 @@ for (const oid of Object.values(numberOids)) {
   types.setTypeParser(oid, Number);
 }
 
-const config = {
+const knexConfig = {
   client: 'postgresql',
   connection: {
     host: process.env.DATABASE_HOST,
@@ -1637,12 +1644,75 @@ const config = {
   },
 } as const;
 
-export default config;
+export default knexConfig;
+`;
+var GET_ME = `import { gql } from '@smartive/graphql-magic';
+
+export const GET_ME = gql\`
+  query GetMe {
+    me {
+      id
+    }
+  }
+\`;
+`;
+var EXECUTE = `
+import knexConfig from "@/knexfile";
+import { Context, User, execute } from "@smartive/graphql-magic";
+import { randomUUID } from "crypto";
+import { knex } from 'knex';
+import { DateTime } from "luxon";
+import { models } from "../config/models";
+
+export const executeGraphql = async <T, V = undefined>(
+  body: {
+    query: string;
+    operationName?: string;
+    variables?: V;
+    options?: { email?: string };
+}): Promise<{ data: T }> => {
+  const db = knex(knexConfig);
+  let user: User | undefined;
+  // TODO: get user
+
+  const result = await execute({
+    req: null as unknown as Context['req'],
+    body,
+    knex: db as unknown as Context['knex'],
+    locale: 'en',
+    locales: ['en'],
+    user,
+    models: models,
+    permissions: { ADMIN: true, UNAUTHENTICATED: true },
+    now: DateTime.local(),
+  });
+  await db.destroy();
+
+  // https://github.com/vercel/next.js/issues/47447#issuecomment-1500371732
+  return JSON.parse(JSON.stringify(result)) as { data: T };
+}
 `;
 
 // src/bin/gqm/settings.ts
 var SETTINGS_PATH = ".gqmrc.json";
+var DEFAULT_ENV = {
+  DATABASE_HOST: "localhost",
+  DATABASE_NAME: "postgres",
+  DATABASE_USER: "postgres",
+  DATABASE_PASSWORD: "password"
+};
 var DEFAULTS = {
+  knexfilePath: {
+    question: "What is the knexfile path?",
+    defaultValue: "knexfile.ts",
+    init: (path) => {
+      for (const [name2, value2] of Object.entries(DEFAULT_ENV)) {
+        ensureFileContains(".env", `${name2}=`, `${name2}=${value2}
+`);
+      }
+      ensureFileExists(path, KNEXFILE);
+    }
+  },
   modelsPath: {
     question: "What is the models path?",
     defaultValue: "src/config/models.ts",
@@ -1654,6 +1724,7 @@ var DEFAULTS = {
     question: "What is the path for generated stuff?",
     defaultValue: "src/generated",
     init: (path) => {
+      ensureFileContains(".gitignore", GITIGNORE(path));
       ensureFileExists(`${path}/.gitkeep`, "");
       ensureFileExists(`${path}/db/.gitkeep`, "");
       ensureFileExists(`${path}/api/.gitkeep`, "");
@@ -1661,10 +1732,11 @@ var DEFAULTS = {
     }
   },
   graphqlQueriesPath: {
-    question: "Where to look for graphql queries?",
-    defaultValue: "src/graphql/client/queries",
+    question: "Where to put graphql code?",
+    defaultValue: "src/graphql",
     init: (path) => {
-      ensureDirectoryExists(path);
+      ensureFileExists(`${path}/client/queries/get-me.ts`, GET_ME);
+      ensureFileExists(`${path}/execute.ts`, EXECUTE);
     }
   },
   gqlModule: {
@@ -1730,6 +1802,13 @@ var ensureFileExists = (filePath, content) => {
     (0, import_fs.writeFileSync)(filePath, content);
   }
 };
+var ensureFileContains = (filePath, content, fallback) => {
+  ensureFileExists(filePath, "");
+  const fileContent = (0, import_fs.readFileSync)(filePath, "utf-8");
+  if (!fileContent.includes(content)) {
+    (0, import_fs.writeFileSync)(filePath, fileContent + (fallback ?? content));
+  }
+};
 var writeToFile = (filePath, content) => {
   ensureDirectoryExists((0, import_path.dirname)(filePath));
   if ((0, import_fs.existsSync)(filePath)) {
@@ -1767,6 +1846,7 @@ var generateGraphqlApiTypes = async () => {
 var generateGraphqlClientTypes = async () => {
   const generatedFolderPath = await getSetting("generatedFolderPath");
   const graphqlQueriesPath = await getSetting("graphqlQueriesPath");
+  ensureDirectoryExists(graphqlQueriesPath);
   await (0, import_cli.generate)({
     schema: `${generatedFolderPath}/schema.graphql`,
     documents: [graphqlQueriesPath, `${generatedFolderPath}/client/mutations.ts`],
@@ -1790,7 +1870,8 @@ var generateGraphqlClientTypes = async () => {
       },
       scalars: {
         DateTime: "string"
-      }
+      },
+      ignoreNoDocuments: true
     }
   });
 };
@@ -2038,16 +2119,16 @@ var findDeclaration = (syntaxList, name2) => {
 };
 
 // src/bin/gqm/parse-knexfile.ts
-var KNEXFILE_PATH = `knexfile.ts`;
 var parseKnexfile = async () => {
   const project = new import_ts_morph4.Project({
     manipulationSettings: {
       indentationText: import_ts_morph4.IndentationText.TwoSpaces
     }
   });
-  ensureFileExists(KNEXFILE_PATH, KNEXFILE);
-  const sourceFile = project.addSourceFileAtPath(KNEXFILE_PATH);
-  const configDeclaration = findDeclarationInFile(sourceFile, "config");
+  const knexfilePath = await getSetting("knexfilePath");
+  ensureFileExists(knexfilePath, KNEXFILE);
+  const sourceFile = project.addSourceFileAtPath(knexfilePath);
+  const configDeclaration = findDeclarationInFile(sourceFile, "knexConfig");
   const config2 = staticEval(configDeclaration, {});
   return config2;
 };
@@ -2077,11 +2158,8 @@ var parseModels = async () => {
   path: ".env.local"
 });
 import_commander.program.description("The graphql-magic cli.");
-import_commander.program.command("setup").description("Set up the project").action(async () => {
-  await getSettings();
-  ensureFileExists(KNEXFILE_PATH, KNEXFILE);
-});
 import_commander.program.command("generate").description("Generate all the things").action(async () => {
+  await getSetting("knexfilePath");
   const models = await parseModels();
   const generatedFolderPath = await getSetting("generatedFolderPath");
   const gqlModule = await getSetting("gqlModule");
@@ -2092,36 +2170,6 @@ import_commander.program.command("generate").description("Generate all the thing
   await generateGraphqlApiTypes();
   await generateGraphqlClientTypes();
 });
-import_commander.program.command("generate-models").description("Generate models.json").action(async () => {
-  await parseModels();
-});
-import_commander.program.command("generate-schema").description("Generate schema").action(async () => {
-  const models = await parseModels();
-  const generatedFolderPath = await getSetting("generatedFolderPath");
-  writeToFile(`${generatedFolderPath}/schema.graphql`, printSchemaFromModels(models));
-});
-import_commander.program.command("generate-mutation-queries").description("Generate mutation-queries").action(async () => {
-  const models = await parseModels();
-  const generatedFolderPath = await getSetting("generatedFolderPath");
-  const gqlModule = await getSetting("gqlModule");
-  writeToFile(`${generatedFolderPath}/client/mutations.ts`, generateMutations(models, gqlModule));
-});
-import_commander.program.command("generate-db-types").description("Generate DB types").action(async () => {
-  const models = await parseModels();
-  const generatedFolderPath = await getSetting("generatedFolderPath");
-  writeToFile(`${generatedFolderPath}/db/index.ts`, generateDBModels(models));
-});
-import_commander.program.command("generate-knex-types").description("Generate Knex types").action(async () => {
-  const models = await parseModels();
-  const generatedFolderPath = await getSetting("generatedFolderPath");
-  writeToFile(`${generatedFolderPath}/db/knex.ts`, generateKnexTables(models));
-});
-import_commander.program.command("generate-graphql-api-types").description("Generate Graphql API types").action(async () => {
-  await generateGraphqlApiTypes();
-});
-import_commander.program.command("generate-graphql-client-types").description("Generate Graphql client types").action(async () => {
-  await generateGraphqlClientTypes();
-});
 import_commander.program.command("generate-migration [<name>] [<date>]").description("Generate Migration").action(async (name2, date) => {
   const git = (0, import_simple_git.simpleGit)();
   if (!name2) {