type AccountType @default(DEFAULT)

test

test org

test2 org

test3 org

contains

node_modules/.prisma/client/index.d.ts(6,26): error TS2307: Cannot find module '@prisma/client/runtime/proxy' or its corresponding type declarations.

model ShopifyOfflineStoreSession {
  pk          String    @id(map: "PK_d371917bab72a48d6cce7880fc5") @default(dbgenerated("uuid_generate_v4()")) @db.Uuid
  id          String    @unique(map: "UQ_91ede9e23efbd7ee27b37bdd9ba") @db.VarChar
  store       Store?    @relation(fields: [pk], references: [shopifyOfflineSessionPk], onDelete: Cascade, onUpdate: Cascade, map: "FK_901a837fbbf20119aded3682f90")

  @@map("shopify_store_session")
}


model Store {
  id                       Int                         @id(map: "PK_f3172007d4de5ae8e7692759d79") @default(autoincrement())
  shopifyOfflineSessionPk  String?                     @unique(map: "UQ_901a837fbbf20119aded3682f90") @db.Uuid
  shopifyOfflineSession    ShopifyOfflineStoreSession?

  @@map("store")
}

await this.prisma.shopifyOfflineStoreSession.create({
        data: {
          ...session,
          store: { connect: { id: store.id } },
        },
      });

db     | 2022-06-10 16:41:02.035 UTC [15541] ERROR:  null value in column "pk" violates not-null constraint
db     | 2022-06-10 16:41:02.035 UTC [15541] DETAIL:  Failing row contains (null, <http://offline_subbooks2.myshopify.com|offline_subbooks2.myshopify.com>, 2022-06-10 16:41:02.033, 2022-06-10 16:41:02.033, null, <http://subbooks2.myshopify.com|subbooks2.myshopify.com>, <some long number here>, f, null, null, null).
db     | 2022-06-10 16:41:02.035 UTC [15541] STATEMENT:  INSERT INTO "public"."shopify_store_session" ("pk","id","createdAt","updatedAt","shop","state","isOnline") VALUES ($1,$2,$3,$4,$5,$6,$7) RETURNING "public"."shopify_store_session"."pk"
api    | Issue saving Shopify offline token. Err: PrismaClientKnownRequestError:
api    | Invalid `this.prisma.shopifyOfflineStoreSession.create()` invocation in
api    | /usr/src/api/src/store/store.service.ts:576:52
api    |
api    |    573     data: session,
api    |    574   });
api    |    575 } else {
api    | →  576   await this.prisma.shopifyOfflineStoreSession.create(
api    |   Null constraint violation on the fields: (`pk`)
api    |     at cb (/usr/src/api/node_modules/@prisma/client/runtime/index.js:38683:17) {
api    |   code: 'P2011',
api    |   clientVersion: '3.6.0',
api    |   meta: { constraint: [ 'pk' ] }
api    | }
api    | query: DELETE FROM "store" WHERE "id" IN ($1) -- PARAMETERS: [18]

pk

shopifyOfflineStoreSession

const result = await prisma.stat.count({
    by: ["userId"]
});

prisma db push

prisma studio

prisma:info Starting a mssql pool with 13 connections.
prisma:info Performing a TLS handshake
prisma:warn Trusting the server certificate without validation.
prisma:info TLS handshake successful
prisma:error Login failed for user 'giqconnect'.

findUnique

graphql-shield

rule.ts

import { rule, and, or, not } from "graphql-shield";
import { GraphQLContext } from "..";

const isValidInvitation = rule()(
  async (parent, args, ctx: GraphQLContext, info) => {
    console.log("parent", parent);
    console.log("args", args);
    console.log("ctx", ctx);

    return false;
  }
);

export default { isValidInvitation };

permissions/index.ts

import { shield } from "graphql-shield";
import rules from "./rules";

const permissions = shield({
  Mutation: {
    createInvitedUser: rules.isValidInvitation,
  },
});

export default permissions;

src/index.ts

import { applyMiddleware } from "graphql-middleware";
import { schema } from "./api/schema";
import permissions from "./permisions";

const secureSchema = applyMiddleware(schema, permissions);
...
startApolloServer(secureSchema, prisma);

RejectOnNotFound

catch (error) {
    if (error instanceof PrismaClientKnownRequestError) {
      throw new AuthenticationError(error.name);
    } else if (
      error instanceof
      (PrismaClientUnknownRequestError || PrismaClientValidationError)
    ) {
      throw new AuthenticationError(error.message);
    }
    // Otherwise send to Sentry so we can debug
    console.log("Authentication Error", error);
    throw new ApolloError("INTERNAL SERVER ERROR", "INTERNAL_SERVER_ERROR");
  }

ERR_PNPM_BAD_PACKAGE_JSON  ****/pnpm-workspace-template/libs/prisma/node_modules/@prisma/client/package.json: Invalid name: “.prisma/client”

.

&& opt

&& !opt

query-engine/core/src/response_ir/internal.rs

express-jwt

Express Apollo Server

express-jwt

export function createContext(
  req: JWTRequest,
  prismaClient: PrismaClient
): GraphQLContext {
  return {
    req,
    prisma: prismaClient,
  };
}

async function startApolloServer(
  gqlSchema: GraphQLSchema,
  prismaClient: PrismaClient
) {
  dotenv.config();

  const app = express();
   // here is how I am using it but when token is invalid it prevents request from proceeding(which is okay) but the errors are not sent back to Apollo Studio Explorer like any other errors raised by resolvers.
  app.use(
    expressjwt({
      secret: process.env.JWT_SECRET!,
      algorithms: ["HS256"],
      credentialsRequired: false,
    })
  );

  // 1. Http Server
  const httpServer = http.createServer(app);

  // 2. Websocket Server
  const wsServer = new WebSocketServer({
    server: httpServer,
    path: "/",
  });

  const wsServerCleanup = useServer({ schema: gqlSchema }, wsServer);

  // 3. Apollo Server
  const server = new ApolloServer({
    schema,
    context: ({ req }) => {
      return createContext(req, prismaClient);
    },
    csrfPrevention: true,
    plugins: [
      // Proper shutdown for the HTTP server.
      ApolloServerPluginDrainHttpServer({ httpServer }),

      // Proper shutdown for the websocket server
      {
        async serverWillStart() {
          return {
            async drainServer() {
              await wsServerCleanup.dispose();
            },
          };
        },
      },
    ],
  });

  await server.start();
  server.applyMiddleware({
    app,
  });

  await new Promise<any>((resolve: any) =>
    httpServer.listen({ port: process.env.PORT }, resolve)
  );
  console.log(`🚀 Server ready at <http://localhost:4000>${server.graphqlPath}`);
}