@smartive/graphql-magic 14.1.0 → 15.0.1

package/src/bin/gqm/templates.ts

@@ -1,7 +1,12 @@
-export const EMPTY_MODELS = `
-import { RawModels, Models } from '@smartive/graphql-magic';
+export const GITIGNORE = (path: string) => `
+# graphql-magic
+${path}/**/*
+${path}/**/.gitkeep
+`;
+
+export const EMPTY_MODELS = `import { ModelDefinitions, Models } from '@smartive/graphql-magic';
 
-const rawModels: RawModels = [
+const modelDefinitions: ModelDefinitions = [
   {
     kind: 'entity',
     name: 'User',
@@ -9,11 +14,10 @@ const rawModels: RawModels = [
   },
 ]
 
-export const models = new Models(rawModels);
+export const models = new Models(modelDefinitions);
 `;
 
-export const KNEXFILE = `
-import { DateTime } from 'luxon';
+export const KNEXFILE = `import { DateTime } from 'luxon';
 import { types } from 'pg';
 
 const dateOids = { date: 1082, timestamptz: 1184, timestamp: 1114 };
@@ -26,7 +30,7 @@ for (const oid of Object.values(numberOids)) {
   types.setTypeParser(oid, Number);
 }
 
-const config = {
+const knexConfig = {
   client: 'postgresql',
   connection: {
     host: process.env.DATABASE_HOST,
@@ -43,5 +47,53 @@ const config = {
   },
 } as const;
 
-export default config;
+export default knexConfig;
+`;
+
+export const GET_ME = `import { gql } from '@smartive/graphql-magic';
+
+export const GET_ME = gql\`
+  query GetMe {
+    me {
+      id
+    }
+  }
+\`;
+`;
+
+export const 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 };
+}
 `;

package/src/context.ts

@@ -17,7 +17,7 @@ export type Context = {
   document: DocumentNode;
   locale: string;
   locales: string[];
-  user: User;
+  user?: User;
   models: Models;
   permissions: Permissions;
   mutationHook?: MutationHook;

package/src/permissions/check.ts

@@ -7,12 +7,14 @@ import { AliasGenerator, hash, ors } from '../resolvers/utils';
 import { BasicValue } from '../values';
 import { PermissionAction, PermissionLink, PermissionStack } from './generate';
 
+export const getRole = (ctx: Pick<FullContext, 'user'>) => ctx.user?.role ?? 'UNAUTHENTICATED';
+
 export const getPermissionStack = (
   ctx: Pick<FullContext, 'permissions' | 'user'>,
   type: string,
   action: PermissionAction
 ): boolean | PermissionStack => {
-  const rolePermissions = ctx.permissions[ctx.user.role];
+  const rolePermissions = ctx.permissions[getRole(ctx)];
   if (typeof rolePermissions === 'boolean' || rolePermissions === undefined) {
     return !!rolePermissions;
   }
@@ -45,7 +47,7 @@ export const applyPermissions = (
   }
 
   if (permissionStack === false) {
-    console.error(`No applicable permissions exist for ${ctx.user.role} ${type} ${action}.`);
+    console.error(`No applicable permissions exist for ${getRole(ctx)} ${type} ${action}.`);
     // eslint-disable-next-line @typescript-eslint/no-floating-promises -- we do not need to await knex here
     query.where(false);
     return permissionStack;
@@ -113,7 +115,7 @@ export const getEntityToMutate = async (
         .map(([key, value]) => `${key}: ${value}`)
         .join(', ')}`
     );
-    throw new PermissionError(ctx.user.role, action, `this ${model.name}`, 'no available permissions applied');
+    throw new PermissionError(getRole(ctx), action, `this ${model.name}`, 'no available permissions applied');
   }
 
   if (model.parent) {
@@ -139,7 +141,7 @@ export const checkCanWrite = async (
     return;
   }
   if (permissionStack === false) {
-    throw new PermissionError(ctx.user.role, action, model.plural, 'no applicable permissions');
+    throw new PermissionError(getRole(ctx), action, model.plural, 'no applicable permissions');
   }
 
   // eslint-disable-next-line @typescript-eslint/no-explicit-any -- using `select(1 as any)` to instantiate an "empty" query builder
@@ -156,13 +158,9 @@ export const checkCanWrite = async (
     }
 
     const fieldPermissions = field[action === 'CREATE' ? 'creatable' : 'updatable'];
-    if (fieldPermissions && typeof fieldPermissions === 'object' && !fieldPermissions.roles?.includes(ctx.user.role)) {
-      throw new PermissionError(
-        ctx.user.role,
-        action,
-        `this ${model.name}'s ${field.name}`,
-        'field permission not available'
-      );
+    const role = getRole(ctx);
+    if (fieldPermissions && typeof fieldPermissions === 'object' && !fieldPermissions.roles?.includes(role)) {
+      throw new PermissionError(role, action, `this ${model.name}'s ${field.name}`, 'field permission not available');
     }
 
     linked = true;
@@ -178,7 +176,7 @@ export const checkCanWrite = async (
 
     if (fieldPermissionStack === false || !fieldPermissionStack.length) {
       throw new PermissionError(
-        ctx.user.role,
+        role,
         action,
         `this ${model.name}'s ${field.name}`,
         'no applicable permissions on data to link'
@@ -194,13 +192,14 @@ export const checkCanWrite = async (
     );
   }
 
+  const role = getRole(ctx);
   if (linked) {
     const canMutate = await query;
     if (!canMutate) {
-      throw new PermissionError(ctx.user.role, action, `this ${model.name}`, 'no linkable entities');
+      throw new PermissionError(role, action, `this ${model.name}`, 'no linkable entities');
     }
   } else if (action === 'CREATE') {
-    throw new PermissionError(ctx.user.role, action, `this ${model.name}`, 'no linkable entities');
+    throw new PermissionError(role, action, `this ${model.name}`, 'no linkable entities');
   }
 };
 
@@ -213,12 +212,21 @@ const permissionLinkQuery = (
   const aliases = new AliasGenerator();
   let alias = aliases.getShort();
   const { type, me, where } = links[0];
-  // eslint-disable-next-line @typescript-eslint/no-floating-promises -- we do not need to await knex here
-  subQuery.from(`${type} as ${alias}`);
+
   if (me) {
+    if (!ctx.user) {
+      // eslint-disable-next-line @typescript-eslint/no-floating-promises -- we do not need to await knex here
+      subQuery.where(false);
+      return;
+    }
+
     // eslint-disable-next-line @typescript-eslint/no-floating-promises -- we do not need to await knex here
     subQuery.where({ [`${alias}.id`]: ctx.user.id });
   }
+
+  // eslint-disable-next-line @typescript-eslint/no-floating-promises -- we do not need to await knex here
+  subQuery.from(`${type} as ${alias}`);
+
   if (where) {
     applyWhere(ctx.models.getModel(type, 'entity'), subQuery, alias, where, aliases);
   }

package/src/resolvers/filters.ts

@@ -38,7 +38,7 @@ export const applyFilters = (node: FieldResolverNode, query: Knex.QueryBuilder,
       normalizedArguments.where.deleted &&
       (!Array.isArray(normalizedArguments.where.deleted) || normalizedArguments.where.deleted.some((v) => v))
     ) {
-      if (node.ctx.user.role !== 'ADMIN') {
+      if (node.ctx.user?.role !== 'ADMIN') {
         throw new ForbiddenError('You cannot access deleted entries.');
       }
     } else {

package/src/resolvers/mutations.ts

@@ -32,7 +32,7 @@ const create = async (model: EntityModel, { data: input }: { data: any }, ctx: F
   const normalizedInput = { ...input };
   normalizedInput.id = uuid();
   normalizedInput.createdAt = ctx.now;
-  normalizedInput.createdById = ctx.user.id;
+  normalizedInput.createdById = ctx.user?.id;
   if (model.parent) {
     normalizedInput.type = model.name;
   }
@@ -165,7 +165,7 @@ const del = async (model: EntityModel, { where, dryRun }: { where: any; dryRun:
     toDelete[currentModel.name][entity.id as string] = (entity[currentModel.displayField || 'id'] || entity.id) as string;
 
     if (!dryRun) {
-      const normalizedInput = { deleted: true, deletedAt: ctx.now, deletedById: ctx.user.id };
+      const normalizedInput = { deleted: true, deletedAt: ctx.now, deletedById: ctx.user?.id };
       const data = { prev: entity, input: {}, normalizedInput, next: { ...entity, ...normalizedInput } };
       if (ctx.mutationHook) {
         beforeHooks.push(async () => {
@@ -319,7 +319,7 @@ const createRevision = async (model: EntityModel, data: Entity, ctx: Context) =>
       id: revisionId,
       [`${typeToField(model.parent || model.name)}Id`]: data.id,
       createdAt: ctx.now,
-      createdById: ctx.user.id,
+      createdById: ctx.user?.id,
     };
 
     if (model.deletable) {
@@ -354,7 +354,7 @@ const createRevision = async (model: EntityModel, data: Entity, ctx: Context) =>
 const sanitize = (ctx: FullContext, model: EntityModel, data: Entity) => {
   if (model.updatable) {
     data.updatedAt = ctx.now;
-    data.updatedById = ctx.user.id;
+    data.updatedById = ctx.user?.id;
   }
 
   for (const key of Object.keys(data)) {

package/src/resolvers/resolver.ts

@@ -29,6 +29,10 @@ export const resolve = async (ctx: FullContext, id?: string) => {
   const { query, verifiedPermissionStacks } = await buildQuery(node);
 
   if (ctx.info.fieldName === 'me') {
+    if (!node.ctx.user.id) {
+      return undefined;
+    }
+
     void query.where({ [getColumn(node, 'id')]: node.ctx.user.id });
   }
 

package/src/resolvers/resolvers.ts

@@ -3,23 +3,25 @@ import { isRootModel, merge, not, typeToField } from '../models/utils';
 import { mutationResolver } from './mutations';
 import { queryResolver } from './resolver';
 
-export const getResolvers = (models: Models) => ({
-  Query: merge([
-    {
-      me: queryResolver,
-    },
-    ...models.entities
-      .filter(({ queriable }) => queriable)
-      .map((model) => ({
-        [typeToField(model.name)]: queryResolver,
-      })),
-    ...models.entities
-      .filter(({ listQueriable }) => listQueriable)
-      .map((model) => ({
-        [model.pluralField]: queryResolver,
-      })),
-  ]),
-  Mutation: merge<unknown>([
+export const getResolvers = (models: Models) => {
+  const resolvers: Record<string, any> = {
+    Query: merge([
+      {
+        me: queryResolver,
+      },
+      ...models.entities
+        .filter(({ queriable }) => queriable)
+        .map((model) => ({
+          [typeToField(model.name)]: queryResolver,
+        })),
+      ...models.entities
+        .filter(({ listQueriable }) => listQueriable)
+        .map((model) => ({
+          [model.pluralField]: queryResolver,
+        })),
+    ]),
+  };
+  const mutations = [
     ...models.entities
       .filter(not(isRootModel))
       .filter(({ creatable }) => creatable)
@@ -39,13 +41,17 @@ export const getResolvers = (models: Models) => ({
         [`delete${model.name}`]: mutationResolver,
         [`restore${model.name}`]: mutationResolver,
       })),
-  ]),
-  ...Object.assign(
-    {},
-    ...models.entities.filter(isRootModel).map((model) => ({
-      [model.name]: {
-        __resolveType: ({ TYPE }) => TYPE,
-      },
-    }))
-  ),
-});
+  ];
+
+  if (mutations.length) {
+    resolvers.Mutation = merge<unknown>(mutations);
+  }
+
+  for (const model of models.entities.filter(isRootModel)) {
+    resolvers[model.name] = {
+      __resolveType: ({ TYPE }) => TYPE,
+    };
+  }
+
+  return resolvers;
+};

package/src/resolvers/selects.ts

@@ -11,7 +11,7 @@ import {
   getNameOrAlias,
   getSimpleFields,
 } from '.';
-import { PermissionError, UserInputError } from '..';
+import { PermissionError, UserInputError, getRole } from '..';
 
 export const applySelects = (node: ResolverNode, query: Knex.QueryBuilder, joins: Joins) => {
   // Simple field selects
@@ -28,9 +28,10 @@ export const applySelects = (node: ResolverNode, query: Knex.QueryBuilder, joins
             return false;
           }
 
-          if (typeof field.queriable === 'object' && !field.queriable.roles?.includes(node.ctx.user.role)) {
+          const role = getRole(node.ctx);
+          if (typeof field.queriable === 'object' && !field.queriable.roles?.includes(role)) {
             throw new PermissionError(
-              node.ctx.user.role,
+              role,
               'READ',
               `${node.model.name}'s field "${field.name}"`,
               'field permission not available'

package/src/schema/generate.ts

@@ -12,7 +12,7 @@ export const generateDefinitions = ({
   entities,
   objects,
 }: Models): DefinitionNode[] => {
-  return [
+  const definitions = [
     // Predefined types
     ...rawEnums.map((model) => enm(model.name, model.values)),
     ...enums.map((model) => enm(model.name, model.values)),
@@ -191,84 +191,90 @@ export const generateDefinitions = ({
         })),
       ...objects.filter((model) => model.name === 'Query').flatMap((model) => model.fields),
     ]),
+  ];
 
-    object('Mutation', [
-      ...entities.flatMap((model): Field[] => {
-        const mutations: Field[] = [];
+  const mutations = [
+    ...entities.flatMap((model): Field[] => {
+      const mutations: Field[] = [];
 
-        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 (!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.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,
-                },
-              ],
-            });
-          }
+        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),
-    ]),
+      return mutations;
+    }),
+    ...objects.filter((model) => model.name === 'Mutation').flatMap((model) => model.fields),
   ];
+
+  if (mutations.length) {
+    definitions.push(object('Mutation', mutations));
+  }
+
+  return definitions;
 };
 
 export const generate = (models: Models) => document(generateDefinitions(models));