.orderBy('user.state = "pending" ', 'DESC')

Running generate... (Use --skip-generate to skip the generators)
Error: Get DMMF: Schema parsing - Error while interacting with query-engine-node-api library
Error code: P1012
error: The preview feature "orderByNulls" is not known. Expected one of: filterJson, referentialIntegrity, mongoDb, interactiveTransactions, fullTextSearch, fullTextIndex,

findUnique

findMany({ where: { id: { in: ['id1', 'id2'] } } })

await prisma.section.findMany({
      where: {
        OR: identifiers.map(({ resourceId, index }) => ({
          resourceId,
          index
        }))
      }
    })

10:39:53 api-service | SyntaxError: Unexpected end of JSON input
10:39:53 api-service |     at JSON.parse (<anonymous>)
10:39:53 api-service |     at /Users/XXX/WorkSpace/XXX/node_modules/@prisma/client/runtime/index.js:27224:31
10:39:53 api-service |     at processTicksAndRejections (node:internal/process/task_queues:96:5)

async byConditionAndType(
    accountId: string,
    input: PatientDataLogGetInput,
    take?: number,
    cursor?: Prisma.DataLogWhereUniqueInput,
  ): Promise<DataLog[]> {
    return await this.prisma.dataLog.findMany({
      take,
      skip: 1,
      cursor,
      where: {
        accountId: accountId,
        condition: input.condition,
        logType: input.logType,
      },
      orderBy: {
        createdAt: 'desc',
      },
    });
  }

@Query(() => [OutputType])
  async getDataLogsByConditionAndType(
    @Args('input') input: DataLogGetInput,
    @Args('take') take?: number,
    @Args('cursor') cursor?: Prisma.PatientDataLogWhereUniqueInput,  
  ): Promise<DataLog[]> {
    const accountId = context.req.user?.accountId;

    try {
      return await this.dataLogService.byConditionAndType(accountId, input, take, cursor);
    } catch (e) {
      throw new ApolloError(e.message);
    }
  }

Undefined type error. Make sure you are providing an explicit type for the "getDataLogsByConditionAndType" (parameter at index [3]) of the "DataLogResolver" class.

cursor

return await this.alertRepository.update({
      where: {
        id,
      },
      data: {
        ...alertData,
        AlertAction: {
          updateMany: {
            data: AlertAction,
            where: {},
          },
        },
      },
    });

TypeError: value.map is not a function
    at tryInferArgs

server {
    listen 80; # you can use 443 and letsencrypt to get SSL for free
    server_name 143.198.151.73; # domain name
    #access_log /var/log/somestuff/access.log; # mkdir dir first
    #error_log /var/log/somestuff/error.log error;

    # for public asset into _next directory
    location _next/ {
        alias /var/www/html/nextjs/.next/;
        expires 30d;
        access_log on;

    location / {
        # reverse proxy for next server
        proxy_pass <http://localhost:8000>; # your nextJs service and port
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;

        # we need to remove this 404 handling
        # because next's _next folder and own handling
        # try_files $uri $uri/ =404;
        }
    }

}

primary key

create table shipment_entry_detail (
	shipment_entry_id uuid
	shipment_entry_detail_id int
	notes text
);

shipment_entry_detail_id

shipment_entry_id

shipment_entry_detail_id

/opt/prisma-binary

PRISMA_QUERY_ENGINE_BINARY

create

Invalid `this.prisma.user.create()` invocation in
/var/task/src/lambda.js:482655:43

  482652     throw new Error("Not found. Proceeding to create!");
  482653   }
  482654 } catch (_a4) {
→ 482655   user = await this.prisma.user.create(
  spawn /opt/prisma-binary EACCES
    at RequestHandler.request (/var/task/src/lambda.js:123709:19)
    at processTicksAndRejections (node:internal/process/task_queues:96:5)
    at async PrismaService._request (/var/task/src/lambda.js:124590:22)
    at async AuthService.verifyOTP (/var/task/src/lambda.js:482655:20) {
  code: 'EACCES',
  clientVersion: '3.15.2',
  meta: undefined
}

model PairReading {
  pair         String   @db.VarChar
  time         DateTime @db.Timestamptz(6)
  reading0     Decimal  @db.Decimal
  reading1     Decimal  @db.Decimal
}

{
        pair: '1542-AC',
        time: 2022-07-20T00:00:00.000Z,
        reading0: 999999961227775700000,
        reading1: 0.000007021900962402
}

code: 'P2033',
    clientVersion: '4.1.0',
    meta: {
      details: "Query parsing failure: A number used in the query does not fit into a 64 bit signed integer. Consider using `BigInt` as field type if you're trying to store large integers."
    }