typescript
// init prisma-appsync client
const app = new PrismaAppSync({
  connectionUrl: process.env.CONNECTION_URL
})

// direct lambda resolver for appsync
export const main = async (event) => {
  // parse the `event` from your Lambda function
  app.parseEvent(event)

  // handle CRUD operations / resolve query
  const result = await app.resolve()

  // close database connection
  await app.prisma.$disconnect()

  // return query result
  return Promise.resolve(result)
}

typescript
const prismaAppSync = new PrismaAppSync()

// direct lambda resolver for appsync
export const resolver = async (event) => {
  return await prismaAppSync.resolve({ event })
}

typescript
app.registerCustomResolvers({
  notify: async ({ args }: CustomResolverProps) => {
    return {
      message: `${args.message} from notify`
    }
  }
})

typescript
return await prismaAppSync.resolve<'notify'>({
  event,
  resolvers: {
    notify: async ({ args }: QueryParams) => {
      return {
        message: `${args.message} from notify`,
      }
    },
  }
})

typescript
// execute before resolve
app.beforeResolve(async (props) => {})

// execute after resolve
app.afterResolve(async (props) => {})

typescript
return await prismaAppSync.resolve<'likePost'>({
  event, // AppSync event
  hooks: {
    // execute before any query
    'before:**': async (props) => {},

    // execute after any query
    'after:**': async (props) => {},

    // execute after custom resolver query `likePost`
    // (e.g. `query { likePost(postId: 3) }`)
    'after:likePost': async ({ prismaClient, authIdentity, args }) => {
      await prismaClient.notification.create({
        data: {
          event: 'POST_LIKED',
          targetId: args.postId,
          userId: authIdentity.sub,
        }
      })
    },
  }
})

typescript
// before resolving any query
app.beforeResolve(async ({ authIdentity }: BeforeResolveProps) => {
  // rules only apply to Cognito authorization type
  if (authIdentity.authorization !== AuthModes.AMAZON_COGNITO_USER_POOLS) {
    return false
  }

  // get current user from database, using Prisma
  // we only need to know the user ID
  const currentUser = await prisma.user.findUnique({
    select: { id: true },
    where: { cognitoSub: authIdentity.sub }
  }) || { id: null }

  // everyone can access (get + list) or create Posts
  app.allow({ action: AuthActions.access, subject: 'Post' })
  app.allow({ action: AuthActions.create, subject: 'Post' })

  // only the author is allowed to modify a given Post 
  app.deny({
    action: AuthActions.modify,
    subject: 'Post',
    // IF `Post.ownerId` NOT_EQUAL_TO `currentUser.id` THEN DENY_QUERY
    condition: { ownerId: { $ne: currentUser.id } }
  })
})

typescript
return await prismaAppSync.resolve({
  event,
  shield: ({ authorization, identity }: QueryParams) => {
    const isCognitoAuth = authorization === Authorizations.AMAZON_COGNITO_USER_POOLS
    const isOwner = { owner: { cognitoSub: identity?.sub } } // Prisma syntax

    return {
      '**': {
        rule: isCognitoAuth,
        reason: ({ model }) => `${model} access is restricted to logged-in users.`,
      },
      'modify/post{,/**}': {
        rule: isOwner,
        reason: ({ model }) => `${model} can only be modified by their owner.`,
      },
    }
  },
})

typescript
const prismaAppSync = new PrismaAppSync({
  // optional, DB connection string, default to env var `DATABASE_URL`
  connectionString,
  // optional, enable data sanitizer for DB storage (incl. XSS parser), default to true
  sanitize,
  // optional, enable debug server logs, default to false
  debug,
  // optional, pagination for listQueries, default to 50
  defaultPagination, 
  // optional, allowed graphql query depth, default to 3
  maxDepth,
})

typescript
generator appsync {
  provider = "prisma-appsync"

  // optional params
  output          = "./generated/prisma-appsync"
  extendSchema    = "./custom-schema.gql"
  extendResolvers = "./custom-resolvers.yaml"
  defaultDirective = "@auth(model: [{ allow: apiKey }])"
}

json
/// @PrismaAppSync.type: '@aws_api_key @aws_cognito_user_pools(cognito_groups: [\"admins\"])'
model Post {
  id       Int       @id @default(autoincrement())
  title    String
}

json
/// @auth(model: [{ allow: apiKey }, { allow: userPools, groups: ["admins"] }])
model Post {
  id       Int       @id @default(autoincrement())
  title    String
}

bash
    ___      _                             _               __
   / _ \_ __(◭)___ _ __ ___   __ _        /_\  _ __  _ __ / _\_   _ _ __   ___
  / /◭)/ '__| / __| '_ ` _ \ / _` |_____ //◭\\| '_ \| '_ \\ \| | | | '_ \ / __|
 / ___/| |  | \__ \ | | | | | (◭| |_____/  _  \ |◭) | |◭) |\ \ |_| | | | | (__
 \/    |_|  |_|___/_| |_| |_|\__,_|     \_/ \_/ .__/| .__/\__/\__, |_| |_|\___|
                                              |_|   |_|       |___/
  ◭ Prisma-AppSync Installer v1.0.0

json
/// @gql(queries: { list: 'posts' }, subscriptions: null)
model Post {
  id       Int       @id @default(autoincrement())
  title    String
}

graphql
mutation {
  updatePost(
    where: { id: 1 }, 
    operation: { 
      views: { increment: 1 }
    }
  ) {
    views
  }
}

graphql
query {
  listPosts(
    where: {
      title: {
        contains: "prisma",
        mode: "insensitive"
      }
    }
  ) {
    title
  }
}

typescript
// Example object returned from the API
{
	"error": "Query has depth of 4, which exceeds max depth of 3.",
	"type": "FORBIDDEN",
	"code": 401
}

// Error codes
const errorCodes = {
    FORBIDDEN: 401,
    BAD_USER_INPUT: 400,
    INTERNAL_SERVER_ERROR: 500,
}