where: {
        applicationId: application.id,
        status: Status.REQUIRED || Status.PENDING,
      },

FROM node:latest

/usr/src/app

COPY _package.json_

./

COPY _pnpm-lock.yaml_

./

RUN _npm_

install

-g

pnpm

RUN _pnpm_

install

RUN _pnpm_

install

-g

prisma

COPY _._

.

8000

RUN _pnpx_

prisma

generate

CMD _[_ "npm"_,_ "run"_,_ "start:prod" _]_

const data = await prisma.customer.groupBy({
        by: ['dueDate'],
        where: {
            status: {
                in: 'PAID',
            },
            merchantId: 1
        },
        _sum: {
            balancePaid: true
        },
        orderBy: {
            dueDate: 'asc'
        }
    })

[
    {
        "dueDate": "2021-11-01T06:30:26.387Z",
        "_sum": {
            "balancePaid": 27337.94
        }
    },
    {
        "dueDate": "2021-11-01T09:26:17.966Z",
        "_sum": {
            "balancePaid": 4320.82
        }
    },
    {
        "dueDate": "2021-11-01T09:43:23.207Z",
        "_sum": {
            "balancePaid": 50684.73
        }
    },
    {
        "dueDate": "2021-11-01T10:10:48.072Z",
        "_sum": {
            "balancePaid": 65238.76
        }
    },

`SELECT COUNT(g.id) AS 'total_used', s.`product_name`, s.`current_period_start` AS 'current_period_start', s.`current_period_end` AS 'current_period_end'
FROM `subscription` s
    JOIN `user` u ON s.`customer_id` = u.`customer_id`
    LEFT JOIN `goat` g ON g.`user_id` = u.`id` AND
          g.`date_created` BETWEEN s.`current_period_start` AND s.`current_period_end`
    WHERE u.`id` = "00000-00000" AND s.`status` = 'ACTIVE'

model User {
  id          String   @id @default(uuid())
  username    String
  roleId      String?
  role        Role?    @relation(fields: [roleId], references: [id])
  contact     Contact?
  acceptCGU   Boolean  @default(false)
  opinons Opinion[]
}

model Role {
  id              String           @id @default(uuid())
  name            String
  description     String
  rolePermissions RolePermission[]
  users           User[]
}

model Opinion {
  id        String   @id @default(uuid())
  opinionCount     Int?
  descriptionOpinion   String?
  user     User      @relation(fields: [authorId], references: [id])
  authorId String
  createdAt DateTime @default(now())
}

Request#1 prisma query ...  
Request#2 prisma query ...  
Request#1 prisma query ...  
Request#2 prisma query ...  
...

const softClone = (c: PrismaClient, context: unknown): PrismaClient

prisma.$on("query", (e) => {
  console.log(e.context, "query", e.query);
});

prisma.schema

export async function getUser(
  request: Request,
  { include }: { include?: Prisma.UserInclude } = {},
) {
  const session = await getUserSession(request)
  const userId = session.get(`userId`)

  if (!userId || typeof userId !== `string`) {
    return null
  }

  return db.user.findUnique({ where: { id: userId }, include })
}

getUser(request, { include: { classes: true } })

Promise<(User & { classes: Class[] }) | null>

Promise<(User & {}) | null>

include

Property 'settings' is missing in type '{ id: string; name: string; username: string; }' but required in type 'UserCreateInput'.ts(2322)

settings

model User {
  id       String  @id @default(cuid())
  username String  @unique
  name     String?
  email    String? @unique
  image    String?

  // relations
  settings   Settings @relation(fields: [settingsId], references: [id], onDelete: Cascade)
  teams      Team[]
  settingsId String
}

model Settings {
  id       String @id @default(cuid())
  timezone String @default("UTC")

  // relations
  user User[]
}

Settings

prisma

res.send

createUser

createUser

Error: 
Invalid `prisma.user.create()` invocation:
  The table `public.Settings` does not exist in the current database.

await prisma.user.create({
		data: {
			id,
			username,
			name,
			settings: {
				connect: {
					id,
				},
			},
		},
	})

SELECT * FROM employees WHERE timesheeting=1 AND year(termination_date)=2021 AND MONTH(termination_date)=10;

DateTime

String

String

model User{
name String
settings: UserSettings
}

submodel UserSettings {
smsNotifications Status
emailNotifications Status
... etc
}

enum Status{
ON
OFF
}

async listAccounts(user: Clients): Promise<AccountResponse[]> {

        const accounts = await this.prismaService.accounts.findMany({
            where: {
                company: {
                    id: user.company.id,
                    deletedAt: null
                }
            }
        })

        return plainToClass(AccountResponse, accounts)
    }