model Account {
  id                   String           @id @default(uuid())
  name                 String
  billingAddress       Address?         @relation("billingAddress", fields: [billingAddressId], references: [id])
  billingAddressId     String?
  fulfillmentAddress   Address?         @relation("fulfillmentAddress", fields: [fulfillmentAddressId], references: [id])
  fulfillmentAddressId String?
  addresses            Address[]
}

model Address {
  id                        String    @id @default(uuid())
  name                      String
  accountBillingAddress     Account[] @relation("billingAddress")
  accountFulfillmentAddress Account[] @relation("fulfillmentAddress")
  account                   Account   @relation(fields: [accountId], references: [id], onDelete: Cascade)
  accountId                 String

  @@unique([name, accountId])
}

billing

fulfillment

{
    id: '1',
    name: 'Catalog',
    addresses: {
      create: [
        {
          id: 'Catalog-HQ',
          name: 'Headquarters',
        },
        {
          name: 'Miami Office',
        },
      ],
    },
    billingAddressId: {
      connect: { name: 'Headquarters' },
    },
    fulfillmentAddress: {
      connect: { name: 'Miami Office' },
    },
  }

Unknown arg `name` in data.fulfillmentAddress.connect.name for type AddressWhereUniqueInput. Did you mean `id`? Available args:
type AddressWhereUniqueInput {
  id?: String
  name_accountId?: AddressNameAccountIdCompoundUniqueInput
}

@@unique([name, accountId])

_<_td _className=_"py-4 pl-3"_>_

_{service.added_date} -> {dayjs(service.added_date).format(_"MMM D, YYYY h:mm A"_)}_

_</_td_>_

_added_date_  DateTime  _@default_(now())

4.4.0

updateMany

upsert

prisma.$transaction

npx prisma db pull

prisma migrate

createMany

prisma.invoice.createMany({
  data: [
    { 
      name: invoice.name, 
      billerId: user.id, 
      invoiceNumber: prisma.invoice.count({where: { billerId: user.id }}) + 1
    }, 
    ... 
  ]
})

prisma.invoice.groupBy({
  by: ['billerId'],
  _count: true
})

prisma.$transaction(async (tx) => {
  const invoiceCountsForBiller = await tx.invoice.groupBy({
    by: ['billerId'],
    _count: true
  })

  await tx.invoice.createMany({
    data: {[
      {
        // ... incorporate invoiceCountsForBiller into logic
      }
    ]}
  })
})

Entry

Campaign

const entries = await ctx.prisma.entry.findMany({
  where: {
    campaigns: { every: { id: { equals: campaignId } } },
  },
});

Entry

Campaign

some: {}

Entry

Campaign

let details: JsonValue | Prisma.DbNull = Prisma.DbNull;

// object.details is JsonValue
object.details = details === Prisma.DbNull ? null : details;

// Error: Type 'JsonValue | DbNull' is not assignable to type 'JsonValue'.
// Type 'DbNull' is not assignable to type 'JsonValue'

object.details = details instanceof Prisma.NullTypes.DbNull ? null : details;

// This works ^^^

create

update

delete

findFirst

findFirstOrThrow

npx prisma db push

jay@Jays-Macbook-Air beam % npx prisma db push
Environment variables loaded from .env
Prisma schema loaded from prisma/schema.prisma
Datasource "db": MySQL database "readyset_beam" at "127.0.0.1:3307"
Error: No database selected
   0: sql_migration_connector::sql_database_step_applier::apply_migration
             at migration-engine/connectors/sql-migration-connector/src/sql_database_step_applier.rs:11
   1: migration_core::state::SchemaPush
             at migration-engine/core/src/state.rs:274

const scorers = await DBConn.recognition_logger.groupBy({
            by: ['receiver_id'],
            _sum: {
                amount: true,
            },
            orderBy: {
                _sum: { amount: 'desc' },
            },
            where: {
                OR: [{ action: 'gave_points' }, { action: 'approve_claimable_award' }, { action: 'custom_award_send' }],
                users_recognition_logger_receiver_idTousers: {
                    active: true,
                },
                amount: { gt: 0 },
                company_id: res.locals.requestingUser.companies.id,
                created: {
                    gte: DateTime.now().startOf('month').startOf('day').toUnixInteger(),
                    lte: DateTime.now().endOf('month').endOf('day').toUnixInteger(),
                },
                hidden_from_leaderboard: false,
                valid: true,
                type: {
                    equals: 'Regular',
                },
            },
        });
        scorers.map(async (e) => {
            const user = await DBConn.users.findUnique({ where: { id: e.receiver_id } });
            console.log(user);
        });

SELECT [*] FROM "public"."users" WHERE "public"."users"."id" IN ($1,$2) OFFSET $3
Params: [157359532448138,165341040401209,0]
Duration: 11ms
null
null

"\nInvalid `prisma.user.findUnique()` invocation:\n\n\nQuery engine library for current platform \"darwin-arm64\" could not be found.

bindaryTargets = ["native", "darwin"]

bindaryTargets = ["native"]

prisma migrate

schema.prisma

INSERT INTO `new`.`Foo`
SELECT `bar`
FROM `old`.`Foo`;