... where: {in: [{columnA: 1, columbB:2}, {columnA: 15, columbB:17}]} ...

export type LessonsCompleted = {
  id: number
  watchedVideo: boolean
  readText: boolean
  completionDate: Date | null
  userId: string
  lessonId: number
}

Lesson

lesson: Lesson

LessonsCompleted

const shelfContents = await prisma.libraryShelves.findUnique({
    where: {
        shelfId: id
    },
    include: {
        shelfRelease: {
            include: {
                releaseArtists: true,
                releaseRecordLabel: true,
                releaseFormats: true,
                releaseStyle: true,
                releaseGenres: true,
                releaseCurrentLocation: true,
                }
            },
        },
});

select: {}

libraryShelves

where@{}

where

where:{
shelfId: id,
shelfPublished: true
}

where:{
shelfId: id,
shelfPublished: true
}

where

"client-version" : "4.1.xxxx"

prisma.foo.findMany({
  where: {
    data: {
      meta: Prisma.AnyNull,
    },
  },
})

prisma.foo.findMany({
  where: {
     meta: Prisma.AnyNull,
  },
})

[tsserver 2322] [E] Type 'AnyNull' is not assignable to type 'JsonNullableFilter'.

createMany

CreateMany

[ERR_HTTP_HEADERS_SENT]: Cannot set headers after they are sent to the client

Live Share in VSC

Code With Me in WebStorm

$queryRaw

where: {
        firstName: { search: 'word' },
        lastName: { search: 'word' },
      } // this is an error

schema.prisma

- project_folder
-- migrate.js
-- src
---- index.ts
---- packages
------- package_1
---------- index.ts
---------- prisma
------------- client
------------- migrations
------------- schema.prisma
------- package_2
---------- index.ts
---------- prisma
------------- client
------------- migrations
------------- schema.prisma

package_1 > prisma > schema.prisma

generator client {
    provider        = "prisma-client-js"
    previewFeatures = ["interactiveTransactions"]
    output          = "./client"
}

datasource db {
    provider = "mysql"
    url      = env("ORGANISATION_CONTEXT_DATABASE_URL")
}

ORGANISATION_CONTEXT_DATABASE_URL

package_2 > prisma > schema.prisma

generator client {
    provider        = "prisma-client-js"
    previewFeatures = ["interactiveTransactions"]
    output          = "./client"
}

datasource db {
    provider = "mysql"
    url      = env("DATABASE_URL")
}

DATABASE_URL

ci.yml

- name: "Run migrations"
     run: yarn migrate

package.json

{
  "scripts": {
    "migrate": "node migrate.js"
  }
}

migrate.js

process.env.ORGANISATION_CONTEXT_DATABASE_URL = 'postgressql://....'

const organisationContextSchema='./src/packages/package_1/prisma/prisma.schema'
const cmd1 = spawnSync('npx', ['prisma', 'generate', `--schema=${organisationContextSchema}`]);

const cmd2 = spawnSync('npx', ['prisma', 'migrate', 'deploy', `--schema=${organisationContextSchema}`]);

// HERE IS WHERE PROBLEMS HAPPEN!!!! :(
const orgContDbClient = new PrismaClient({
    datasources: { db: { url: process.env.ORGANISATION_CONTEXT_DATABASE_URL } },
});

console.log('connected! Fetching orgs...');
const dbOrgs = await orgContDbClient.organisation.findMany();

console.log('dbOrgs: ', dbOrgs);

Error: @prisma/client did not initialize yet. Please run "prisma generate" and try to import it again.

Error querying the database: Server error: `ERROR 08S01 (1043): Bad handshake'

prisma.$queryRaw`BEGIN`
prisma.$queryRaw`pg_advisory_xact_lock(5)`
// code, processing
prisma.$queryRaw`pg_advisory_xact_unlock(5)`
prisma.$queryRaw`COMMIT`

prisma.concept.findMany({
    where: {
      dictionaryId: Number(dictId),
      name: {contains: foo}
    },
    include: {
      _count: {
        select: {
          declarations: true, // including this in the query makes it super slow
        },
      },
    }
  })

$queryRaw()

const rows = await this.prismaClient.$queryRaw<
  { id: string; location: string }[]
>(Prisma.sql`
  SELECT id, ST_AsGeoJSON(location) as location,
  FROM something
  WHERE id IN (${Prisma.join(ids)})
`);

ERROR: operator does not exist: uuid = text

ids

IN (${Prisma.join(ids)}::uuid[]) IN (${Prisma.join(ids)})::uuid[]

model Report {
  id            String        @id @default(auto()) @map("_id") @db.ObjectId
  ...
  team          Team          @relation(fields: [teamId], references: [id])
  teamId        String 
  ...
}

model Team {
  id                   String             @id @map("_id")
  ...
  reports              Report[]
  ...
}

const report = await prisma.report.create({
        data: {
            id : newId.toString(),
            teamId:        teamId,
            ...
        },
    });

"Parse errors: [Query parsing/validation error at Mutation.createOneReport.data.ReportCreateInput.team: A value is required but not set"

const report = await prisma.report.create({
        data: {
            id : newId.toString(),
            ...
            teamId:        teamId,
            team: {
                connect: {
                    id: teamId,
                },
            },
            ...
        },
    });

//schema

model activityLog {
  activityLogId      String                @id @map("_id") @default(uuid())
  activityLogType    activityLogType       @relation(fields: [activityLogTypeId], references: [activityLogType])
  activityLogTypeId  String                @db.ObjectId()
  activityLogMessage String                @db.String
  activityCompleted  Boolean               @default(false)
  createdAt          DateTime              @default(now()) @db.Timestamp
  updatedAt          DateTime              @default(now()) @db.Timestamp
}

model activityLogType {
  activityLogType     String                @id @map("_id")  @db.String
  createdAt           DateTime              @default(now()) @db.Timestamp
  updatedAt           DateTime              @default(now()) @db.Timestamp
  activityLog         activityLog[]
}

await prisma.activityLog.create({
    data: {
      activityLogType: {
        activityLogType: "Start"
      },
      activityLogMessage: "Start Seeding",
      activityCompleted: true
    }
  })

Start

activityLogTypes

activityLogType

/core/prisma/schema.prisma
/lambda/prisma/schema.prisma

lambda

core/prisma/schema.prisma

model Collection {
    id                String    @id @default(auto()) @map("_id") @db.ObjectId
    network           String
    contract_address  String    @unique
    @@map("collections")
}

core/models/collections.ts

export const FindCollections = async () => {
    try {
        const contracts = await PrismaService.collection.findMany();

        return [contracts, null] as const;
    } catch (err) {
        Logger.error({ kind: "FindCollections", error: err.name, stack_trace: err.stack });
        return [null, err] as const;
    }
};

lambda/prisma/prisma.schema

model collections {
  id                String   @id @default(auto()) @map("_id") @db.ObjectId
  contract_address  String
  ...
}

InsertCollections","stack_trace":"Error: Could not find mapping for model Collection\n