prisma db push

{include: true}

books {
  name
  author {
    name
  }
}

const books = await prisma.book.findMany({include: {author: true}})

const { field } = params
const { priority, status } = query

const groups = await db.issue.groupBy({
	where: {
		priority: {
			in: priority,
		},
		status: {
			in: status,
		},
	},
	by: [field],
	_count: true,
	orderBy: {
		[field]: 'desc',
	},
})
return groups

[
	{
		"_count": 338,
		"status": "open"
	},
	{
		"_count": 312,
		"status": "in review"
	},
	{
		"_count": 359,
		"status": "in progress"
	},
	{
		"_count": 314,
		"status": "done"
	},
	{
		"_count": 366,
		"status": "canceled"
	},
	{
		"_count": 329,
		"status": null
	}
]

companyId

@@id([jobId, productId, companyId])

/// Intermediary between Job and Product
model Freight {
  tonnage   Float?
  amount    Int?
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt
  job       Job      @relation(fields: [jobId], references: [id], onDelete: Cascade)
  jobId     String
  product   Product  @relation(fields: [productId], references: [id], onDelete: Cascade)
  productId String
  reciever  Company? @relation(fields: [companyId], references: [id], onDelete: Cascade)
  companyId String
  pieces    Piece[]

  @@id([jobId, productId, companyId])
}

model Piece {
  id               String        @id @default(cuid())
  number           Int
  time             DateTime      @default(now())
  createdAt        DateTime      @default(now())
  updatedAt        DateTime      @updatedAt
  freight          Freight       @relation(fields: [freightJobId, freightProductId, freightCompanyId], references: [jobId, productId, companyId], onDelete: Cascade)
  freightJobId     String
  freightProductId String
  freightCompanyId String
  damages          PieceDamage[]
}

XUncheckedWithoutYInput

XOR<Enumberable<XWithoutYInput>, Enumerable<XUncheckedWithoutYInput>>

SELECT date(extract_created_at)

FROM payment_gateway_extracts

WHERE client_id = ${clientId}

GROUP BY date(extract_created_at)

ORDER BY date(extract_created_at) DESC

OFFSET ${skip}

LIMIT ${take}

export async function getProducts({
  filters,
  page,
  limit,
  orderBy = { Name: "asc" },
  searchTerm = "",
}: {
  filters: string[];
  page: number;
  limit: number;
  orderBy?: Record<string, string>;
  searchTerm: string;
}): Promise<
  Prisma.ProductGetPayload<{
    include: { Category: true };
  }>[]
> {
  const { skip, take } = getItemsPaginated({ page, limit });
  const prismaDBFilters = filters.map((filter) => ({
    Name: { equals: filter },
  }));
  if (prismaDBFilters.length) {
    return await prisma.product.findMany({
      orderBy,
      skip,
      take,
      where: {
        Name: {
          contains: searchTerm,
        },
        Category: {
          OR: prismaDBFilters,
        },
      },
      include: {
        Category: true,
      },
    });
  } else {
    return await prisma.product.findMany({
      orderBy,
      skip,
      take,
      where: {
        Name: {
          contains: searchTerm,
        },
      },
      include: {
        Category: true,
      },
    });
  }
}

type UserIntensitySetting {
  id: UUID! @id
  category: WorkoutCategory!
  historicalIntensitySettings: [HistoricalIntensitySetting!]! @relation(onDelete: CASCADE)
  user: User!
  createdAt: DateTime! @createdAt
}

... await context.prisma.userIntensitySetting({ id: 'asdf-basdf-waaa-234' });

... await context.prisma.userIntensitySetting({ category: 'strength' });

The column `(not available)` does not exist in the current database.

Type error: Property 'category' does not exist on type 'PrismaClient<PrismaClientOptions, never, RejectOnNotFound | RejectPerOperation | undefined>'.

const after = prisma.deviceEvent
          .findMany({
            where: {
              device_id: device_id || undefined,
              timestamp: {
                gte: args.start_date || undefined,
                lt: args.end_date || undefined,
              },
            },
          })

const before = prisma.deviceEvent
          .findFirst({
            where: {
              device_id: device_id || undefined,
              timestamp: {
                lte: args.start_date || undefined,
              },
            },
          })

return [before, ...after];

before

after