Converter
Converter copied to clipboard
Published
20 hours ago •
ScalablyTyped
ScalablyTyped
Unspecified value parameter executor
Hi, as you probably have guessed, I'm trying to evaluate ORMs from the JS world to use from scalajs. :rocket:
sbt-converter: 1.0.0-beta37
Scala: 2.13
This time I'm trying to convert a generated Prisma client (https://www.prisma.io/docs/concepts/components/prisma-client/working-with-prismaclient/generating-prisma-client).
It seems that they have their own Promise type defined, which causes problems. But I wasn't able to figure out why exactly the Scala code is not compiling.
error:
[error] ZincCompiler.scala:230 msg.get() [Error] /.../target/streams/_global/stImport/_global/streams/sources/g/generated-prisma-client/src/main/scala/typings/generatedPrismaClient/mod/Prisma/PrismaTablesClient.scala:15: not enough arguments for constructor Promise: (executor: scala.scalajs.js.Function2[scala.scalajs.js.Function1[T | scala.scalajs.js.Thenable[T], _], scala.scalajs.js.Function1[Any, _], _]): scala.scalajs.js.Promise[T].
[error] Unspecified value parameter executor. [project => lambda, ms => 37322]
[error] ZincCompiler.scala:230 msg.get() one error found [project => lambda, ms => 39236]
[error] Phase3Compile.scala:147 err Compilation failed: -Xplugin:/.../.cache/coursier/v1/https/repo1.maven.org/maven2/org/scala-js/scalajs-compiler_2.13.8/1.8.0/scalajs-compiler_2.13.8-1.8.0.jar, -encoding, utf-8, -feature, -g:notailcalls, -language:implicitConversions, -language:higherKinds, -language:existentials, -bootclasspath, /.../.cache/coursier/v1/https/repo1.maven.org/maven2/org/scala-lang/scala-library/2.13.8/scala-library-2.13.8.jar:/.../.cache/coursier/v1/https/repo1.maven.org/maven2/org/scala-lang/scala-library/2.13.8/scala-library-2.13.8.jar:/.../.cache/coursier/v1/https/repo1.maven.org/maven2/org/scala-lang/scala-library/2.13.8/scala-library-2.13.8.jar, -classpath, /.../.cache/coursier/v1/https/repo1.maven.org/maven2/org/scala-lang/scala-compiler/2.13.8/scala-compiler-2.13.8.jar:/.../.cache/coursier/v1/https/repo1.maven.org/maven2/org/scala-lang/scala-reflect/2.13.8/scala-reflect-2.13.8.jar:/.../.cache/coursier/v1/https/repo1.maven.org/maven2/org/jline/jline/3.21.0/jline-3.21.0.jar:/.../.cache/coursier/v1/https/repo1.maven.org/maven2/net/java/dev/jna/jna/5.9.0/jna-5.9.0.jar:/.../.cache/coursier/v1/https/repo1.maven.org/maven2/org/scala-js/scalajs-library_2.13/1.8.0/scalajs-library_2.13-1.8.0.jar:/.../.cache/coursier/v1/https/repo1.maven.org/maven2/org/scala-js/scalajs-compiler_2.13.8/1.8.0/scalajs-compiler_2.13.8-1.8.0.jar:/.../.ivy2/local/org.scalablytyped/node_sjs1_2.13/17.0.8-56389b/jars/node_sjs1_2.13.jar:/.../.ivy2/local/org.scalablytyped/std_sjs1_2.13/4.3-8f2b57/jars/std_sjs1_2.13.jar:/.../.cache/coursier/v1/https/repo1.maven.org/maven2/org/scala-js/scalajs-dom_sjs1_2.13/2.0.0/scalajs-dom_sjs1_2.13-2.0.0.jar:/.../.cache/coursier/v1/https/repo1.maven.org/maven2/org/scala-js/scalajs-library_2.13/1.5.1/scalajs-library_2.13-1.5.1.jar:/.../.cache/coursier/v1/https/repo1.maven.org/maven2/com/olvind/scalablytyped-runtime_sjs1_2.13/2.4.2/scalablytyped-runtime_sjs1_2.13-2.4.2.jar [Error] /.../target/streams/_global/stImport/_global/streams/sources/g/generated-prisma-client/src/main/scala/typings/generatedPrismaClient/mod/Prisma/PrismaTablesClient.scala:15: not enough arguments for constructor Promise: (executor: scala.scalajs.js.Function2[scala.scalajs.js.Function1[T | scala.scalajs.js.Thenable[T], _], scala.scalajs.js.Function1[Any, _], _]): scala.scalajs.js.Promise[T].
[error] Unspecified value parameter executor. [thread => 687, project => lambda, ms => 39419, phase => build, id => generated-prisma-client, flavour => NormalFlavour]
Prisma Generated Typescript Code
/**
* Client
**/
import * as runtime from './runtime/index';
declare const prisma: unique symbol
export type PrismaPromise<A> = Promise<A> & {[prisma]: true}
type UnwrapPromise<P extends any> = P extends Promise<infer R> ? R : P
type UnwrapTuple<Tuple extends readonly unknown[]> = {
[K in keyof Tuple]: K extends `${number}` ? Tuple[K] extends PrismaPromise<infer X> ? X : UnwrapPromise<Tuple[K]> : UnwrapPromise<Tuple[K]>
};
/**
* Model tables
*
*/
export type tables = {
id: number
name: string | null
}
/**
* ## Prisma Client ʲˢ
*
* Type-safe database client for TypeScript & Node.js
* @example
* ```
* const prisma = new PrismaClient()
* // Fetch zero or more Tables
* const tables = await prisma.tables.findMany()
* ```
*
*
* Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client).
*/
export class PrismaClient<
T extends Prisma.PrismaClientOptions = Prisma.PrismaClientOptions,
U = 'log' extends keyof T ? T['log'] extends Array<Prisma.LogLevel | Prisma.LogDefinition> ? Prisma.GetEvents<T['log']> : never : never,
GlobalReject = 'rejectOnNotFound' extends keyof T
? T['rejectOnNotFound']
: false
> {
/**
* @private
*/
private fetcher;
/**
* @private
*/
private readonly dmmf;
/**
* @private
*/
private connectionPromise?;
/**
* @private
*/
private disconnectionPromise?;
/**
* @private
*/
private readonly engineConfig;
/**
* @private
*/
private readonly measurePerformance;
/**
* ## Prisma Client ʲˢ
*
* Type-safe database client for TypeScript & Node.js
* @example
* ```
* const prisma = new PrismaClient()
* // Fetch zero or more Tables
* const tables = await prisma.tables.findMany()
* ```
*
*
* Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client).
*/
constructor(optionsArg ?: Prisma.Subset<T, Prisma.PrismaClientOptions>);
$on<V extends (U | 'beforeExit')>(eventType: V, callback: (event: V extends 'query' ? Prisma.QueryEvent : V extends 'beforeExit' ? () => Promise<void> : Prisma.LogEvent) => void): void;
/**
* Connect with the database
*/
$connect(): Promise<void>;
/**
* Disconnect from the database
*/
$disconnect(): Promise<void>;
/**
* Add a middleware
*/
$use(cb: Prisma.Middleware): void
/**
* Executes a prepared raw query and returns the number of affected rows.
* @example
* ```
* const result = await prisma.$executeRaw`UPDATE User SET cool = ${true} WHERE email = ${'[email protected]'};`
* ```
*
* Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
*/
$executeRaw<T = unknown>(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): PrismaPromise<number>;
/**
* Executes a raw query and returns the number of affected rows.
* Susceptible to SQL injections, see documentation.
* @example
* ```
* const result = await prisma.$executeRawUnsafe('UPDATE User SET cool = $1 WHERE email = $2 ;', true, '[email protected]')
* ```
*
* Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
*/
$executeRawUnsafe<T = unknown>(query: string, ...values: any[]): PrismaPromise<number>;
/**
* Performs a prepared raw query and returns the `SELECT` data.
* @example
* ```
* const result = await prisma.$queryRaw`SELECT * FROM User WHERE id = ${1} OR email = ${'[email protected]'};`
* ```
*
* Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
*/
$queryRaw<T = unknown>(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): PrismaPromise<T>;
/**
* Performs a raw query and returns the `SELECT` data.
* Susceptible to SQL injections, see documentation.
* @example
* ```
* const result = await prisma.$queryRawUnsafe('SELECT * FROM User WHERE id = $1 OR email = $2;', 1, '[email protected]')
* ```
*
* Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
*/
$queryRawUnsafe<T = unknown>(query: string, ...values: any[]): PrismaPromise<T>;
/**
* Allows the running of a sequence of read/write operations that are guaranteed to either succeed or fail as a whole.
* @example
* ```
* const [george, bob, alice] = await prisma.$transaction([
* prisma.user.create({ data: { name: 'George' } }),
* prisma.user.create({ data: { name: 'Bob' } }),
* prisma.user.create({ data: { name: 'Alice' } }),
* ])
* ```
*
* Read more in our [docs](https://www.prisma.io/docs/concepts/components/prisma-client/transactions).
*/
$transaction<P extends PrismaPromise<any>[]>(arg: [...P]): Promise<UnwrapTuple<P>>;
/**
* `prisma.tables`: Exposes CRUD operations for the **tables** model.
* Example usage:
* ```ts
* // Fetch zero or more Tables
* const tables = await prisma.tables.findMany()
* ```
*/
get tables(): Prisma.tablesDelegate<GlobalReject>;
}
export namespace Prisma {
export import DMMF = runtime.DMMF
/**
* Prisma Errors
*/
export import PrismaClientKnownRequestError = runtime.PrismaClientKnownRequestError
export import PrismaClientUnknownRequestError = runtime.PrismaClientUnknownRequestError
export import PrismaClientRustPanicError = runtime.PrismaClientRustPanicError
export import PrismaClientInitializationError = runtime.PrismaClientInitializationError
export import PrismaClientValidationError = runtime.PrismaClientValidationError
/**
* Re-export of sql-template-tag
*/
export import sql = runtime.sqltag
export import empty = runtime.empty
export import join = runtime.join
export import raw = runtime.raw
export import Sql = runtime.Sql
/**
* Decimal.js
*/
export import Decimal = runtime.Decimal
/**
* Prisma Client JS version: 3.8.1
* Query Engine version: 34df67547cf5598f5a6cd3eb45f14ee70c3fb86f
*/
export type PrismaVersion = {
client: string
}
export const prismaVersion: PrismaVersion
/**
* Utility Types
*/
/**
* From https://github.com/sindresorhus/type-fest/
* Matches a JSON object.
* This type can be useful to enforce some input to be JSON-compatible or as a super-type to be extended from.
*/
export type JsonObject = {[Key in string]?: JsonValue}
/**
* From https://github.com/sindresorhus/type-fest/
* Matches a JSON array.
*/
export interface JsonArray extends Array<JsonValue> {}
/**
* From https://github.com/sindresorhus/type-fest/
* Matches any valid JSON value.
*/
export type JsonValue = string | number | boolean | JsonObject | JsonArray | null
/**
* Matches a JSON object.
* Unlike `JsonObject`, this type allows undefined and read-only properties.
*/
export type InputJsonObject = {readonly [Key in string]?: InputJsonValue | null}
/**
* Matches a JSON array.
* Unlike `JsonArray`, readonly arrays are assignable to this type.
*/
export interface InputJsonArray extends ReadonlyArray<InputJsonValue | null> {}
/**
* Matches any valid value that can be used as an input for operations like
* create and update as the value of a JSON field. Unlike `JsonValue`, this
* type allows read-only arrays and read-only object properties and disallows
* `null` at the top level.
*
* `null` cannot be used as the value of a JSON field because its meaning
* would be ambiguous. Use `Prisma.JsonNull` to store the JSON null value or
* `Prisma.DbNull` to clear the JSON value and set the field to the database
* NULL value instead.
*
* @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-by-null-values
*/
export type InputJsonValue = string | number | boolean | InputJsonObject | InputJsonArray
/**
* Helper for filtering JSON entries that have `null` on the database (empty on the db)
*
* @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
*/
export const DbNull: 'DbNull'
/**
* Helper for filtering JSON entries that have JSON `null` values (not empty on the db)
*
* @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
*/
export const JsonNull: 'JsonNull'
/**
* Helper for filtering JSON entries that are `Prisma.DbNull` or `Prisma.JsonNull`
*
* @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
*/
export const AnyNull: 'AnyNull'
type SelectAndInclude = {
select: any
include: any
}
type HasSelect = {
select: any
}
type HasInclude = {
include: any
}
type CheckSelect<T, S, U> = T extends SelectAndInclude
? 'Please either choose `select` or `include`'
: T extends HasSelect
? U
: T extends HasInclude
? U
: S
/**
* Get the type of the value, that the Promise holds.
*/
export type PromiseType<T extends PromiseLike<any>> = T extends PromiseLike<infer U> ? U : T;
/**
* Get the return type of a function which returns a Promise.
*/
export type PromiseReturnType<T extends (...args: any) => Promise<any>> = PromiseType<ReturnType<T>>
/**
* From T, pick a set of properties whose keys are in the union K
*/
type Prisma__Pick<T, K extends keyof T> = {
[P in K]: T[P];
};
export type Enumerable<T> = T | Array<T>;
export type RequiredKeys<T> = {
[K in keyof T]-?: {} extends Prisma__Pick<T, K> ? never : K
}[keyof T]
export type TruthyKeys<T> = {
[key in keyof T]: T[key] extends false | undefined | null ? never : key
}[keyof T]
export type TrueKeys<T> = TruthyKeys<Prisma__Pick<T, RequiredKeys<T>>>
/**
* Subset
* @desc From `T` pick properties that exist in `U`. Simple version of Intersection
*/
export type Subset<T, U> = {
[key in keyof T]: key extends keyof U ? T[key] : never;
};
/**
* SelectSubset
* @desc From `T` pick properties that exist in `U`. Simple version of Intersection.
* Additionally, it validates, if both select and include are present. If the case, it errors.
*/
export type SelectSubset<T, U> = {
[key in keyof T]: key extends keyof U ? T[key] : never
} &
(T extends SelectAndInclude
? 'Please either choose `select` or `include`.'
: {})
/**
* Subset + Intersection
* @desc From `T` pick properties that exist in `U` and intersect `K`
*/
export type SubsetIntersection<T, U, K> = {
[key in keyof T]: key extends keyof U ? T[key] : never
} &
K
type Without<T, U> = { [P in Exclude<keyof T, keyof U>]?: never };
/**
* XOR is needed to have a real mutually exclusive union type
* https://stackoverflow.com/questions/42123407/does-typescript-support-mutually-exclusive-types
*/
type XOR<T, U> = (T | U) extends object ? (Without<T, U> & U) | (Without<U, T> & T) : T | U;
/**
* Is T a Record?
*/
type IsObject<T extends any> = T extends Array<any>
? False
: T extends Date
? False
: T extends Buffer
? False
: T extends BigInt
? False
: T extends object
? True
: False
/**
* If it's T[], return T
*/
export type UnEnumerate<T extends unknown> = T extends Array<infer U> ? U : T
/**
* From ts-toolbelt
*/
type __Either<O extends object, K extends Key> = Omit<O, K> &
{
// Merge all but K
[P in K]: Prisma__Pick<O, P & keyof O> // With K possibilities
}[K]
type EitherStrict<O extends object, K extends Key> = Strict<__Either<O, K>>
type EitherLoose<O extends object, K extends Key> = ComputeRaw<__Either<O, K>>
type _Either<
O extends object,
K extends Key,
strict extends Boolean
> = {
1: EitherStrict<O, K>
0: EitherLoose<O, K>
}[strict]
type Either<
O extends object,
K extends Key,
strict extends Boolean = 1
> = O extends unknown ? _Either<O, K, strict> : never
export type Union = any
type PatchUndefined<O extends object, O1 extends object> = {
[K in keyof O]: O[K] extends undefined ? At<O1, K> : O[K]
} & {}
/** Helper Types for "Merge" **/
export type IntersectOf<U extends Union> = (
U extends unknown ? (k: U) => void : never
) extends (k: infer I) => void
? I
: never
export type Overwrite<O extends object, O1 extends object> = {
[K in keyof O]: K extends keyof O1 ? O1[K] : O[K];
} & {};
type _Merge<U extends object> = IntersectOf<Overwrite<U, {
[K in keyof U]-?: At<U, K>;
}>>;
type Key = string | number | symbol;
type AtBasic<O extends object, K extends Key> = K extends keyof O ? O[K] : never;
type AtStrict<O extends object, K extends Key> = O[K & keyof O];
type AtLoose<O extends object, K extends Key> = O extends unknown ? AtStrict<O, K> : never;
export type At<O extends object, K extends Key, strict extends Boolean = 1> = {
1: AtStrict<O, K>;
0: AtLoose<O, K>;
}[strict];
export type ComputeRaw<A extends any> = A extends Function ? A : {
[K in keyof A]: A[K];
} & {};
export type OptionalFlat<O> = {
[K in keyof O]?: O[K];
} & {};
type _Record<K extends keyof any, T> = {
[P in K]: T;
};
type _Strict<U, _U = U> = U extends unknown ? U & OptionalFlat<_Record<Exclude<Keys<_U>, keyof U>, never>> : never;
export type Strict<U extends object> = ComputeRaw<_Strict<U>>;
/** End Helper Types for "Merge" **/
export type Merge<U extends object> = ComputeRaw<_Merge<Strict<U>>>;
/**
A [[Boolean]]
*/
export type Boolean = True | False
// /**
// 1
// */
export type True = 1
/**
0
*/
export type False = 0
export type Not<B extends Boolean> = {
0: 1
1: 0
}[B]
export type Extends<A1 extends any, A2 extends any> = [A1] extends [never]
? 0 // anything `never` is false
: A1 extends A2
? 1
: 0
export type Has<U extends Union, U1 extends Union> = Not<
Extends<Exclude<U1, U>, U1>
>
export type Or<B1 extends Boolean, B2 extends Boolean> = {
0: {
0: 0
1: 1
}
1: {
0: 1
1: 1
}
}[B1][B2]
export type Keys<U extends Union> = U extends unknown ? keyof U : never
type Exact<A, W = unknown> =
W extends unknown ? A extends Narrowable ? Cast<A, W> : Cast<
{[K in keyof A]: K extends keyof W ? Exact<A[K], W[K]> : never},
{[K in keyof W]: K extends keyof A ? Exact<A[K], W[K]> : W[K]}>
: never;
type Narrowable = string | number | boolean | bigint;
type Cast<A, B> = A extends B ? A : B;
export const type: unique symbol;
export function validator<V>(): <S>(select: Exact<S, V>) => S;
/**
* Used by group by
*/
export type GetScalarType<T, O> = O extends object ? {
[P in keyof T]: P extends keyof O
? O[P]
: never
} : never
type FieldPaths<
T,
U = Omit<T, '_avg' | '_sum' | '_count' | '_min' | '_max'>
> = IsObject<T> extends True ? U : T
type GetHavingFields<T> = {
[K in keyof T]: Or<
Or<Extends<'OR', K>, Extends<'AND', K>>,
Extends<'NOT', K>
> extends True
? // infer is only needed to not hit TS limit
// based on the brilliant idea of Pierre-Antoine Mills
// https://github.com/microsoft/TypeScript/issues/30188#issuecomment-478938437
T[K] extends infer TK
? GetHavingFields<UnEnumerate<TK> extends object ? Merge<UnEnumerate<TK>> : never>
: never
: {} extends FieldPaths<T[K]>
? never
: K
}[keyof T]
/**
* Convert tuple to union
*/
type _TupleToUnion<T> = T extends (infer E)[] ? E : never
type TupleToUnion<K extends readonly any[]> = _TupleToUnion<K>
type MaybeTupleToUnion<T> = T extends any[] ? TupleToUnion<T> : T
/**
* Like `Pick`, but with an array
*/
type PickArray<T, K extends Array<keyof T>> = Prisma__Pick<T, TupleToUnion<K>>
/**
* Exclude all keys with underscores
*/
type ExcludeUnderscoreKeys<T extends string> = T extends `_${string}` ? never : T
class PrismaClientFetcher {
private readonly prisma;
private readonly debug;
private readonly hooks?;
constructor(prisma: PrismaClient<any, any>, debug?: boolean, hooks?: Hooks | undefined);
request<T>(document: any, dataPath?: string[], rootField?: string, typeName?: string, isList?: boolean, callsite?: string): Promise<T>;
sanitizeMessage(message: string): string;
protected unpack(document: any, data: any, path: string[], rootField?: string, isList?: boolean): any;
}
export const ModelName: {
tables: 'tables'
};
export type ModelName = (typeof ModelName)[keyof typeof ModelName]
export type Datasources = {
db?: Datasource
}
export type RejectOnNotFound = boolean | ((error: Error) => Error)
export type RejectPerModel = { [P in ModelName]?: RejectOnNotFound }
export type RejectPerOperation = { [P in "findUnique" | "findFirst"]?: RejectPerModel | RejectOnNotFound }
type IsReject<T> = T extends true ? True : T extends (err: Error) => Error ? True : False
export type HasReject<
GlobalRejectSettings extends Prisma.PrismaClientOptions['rejectOnNotFound'],
LocalRejectSettings,
Action extends PrismaAction,
Model extends ModelName
> = LocalRejectSettings extends RejectOnNotFound
? IsReject<LocalRejectSettings>
: GlobalRejectSettings extends RejectPerOperation
? Action extends keyof GlobalRejectSettings
? GlobalRejectSettings[Action] extends boolean
? IsReject<GlobalRejectSettings[Action]>
: GlobalRejectSettings[Action] extends RejectPerModel
? Model extends keyof GlobalRejectSettings[Action]
? IsReject<GlobalRejectSettings[Action][Model]>
: False
: False
: False
: IsReject<GlobalRejectSettings>
export type ErrorFormat = 'pretty' | 'colorless' | 'minimal'
export interface PrismaClientOptions {
/**
* Configure findUnique/findFirst to throw an error if the query returns null.
* * @example
* ```
* // Reject on both findUnique/findFirst
* rejectOnNotFound: true
* // Reject only on findFirst with a custom error
* rejectOnNotFound: { findFirst: (err) => new Error("Custom Error")}
* // Reject on user.findUnique with a custom error
* rejectOnNotFound: { findUnique: {User: (err) => new Error("User not found")}}
* ```
*/
rejectOnNotFound?: RejectOnNotFound | RejectPerOperation
/**
* Overwrites the datasource url from your prisma.schema file
*/
datasources?: Datasources
/**
* @default "colorless"
*/
errorFormat?: ErrorFormat
/**
* @example
* ```
* // Defaults to stdout
* log: ['query', 'info', 'warn', 'error']
*
* // Emit as events
* log: [
* { emit: 'stdout', level: 'query' },
* { emit: 'stdout', level: 'info' },
* { emit: 'stdout', level: 'warn' }
* { emit: 'stdout', level: 'error' }
* ]
* ```
* Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/logging#the-log-option).
*/
log?: Array<LogLevel | LogDefinition>
}
export type Hooks = {
beforeRequest?: (options: { query: string, path: string[], rootField?: string, typeName?: string, document: any }) => any
}
/* Types for Logging */
export type LogLevel = 'info' | 'query' | 'warn' | 'error'
export type LogDefinition = {
level: LogLevel
emit: 'stdout' | 'event'
}
export type GetLogType<T extends LogLevel | LogDefinition> = T extends LogDefinition ? T['emit'] extends 'event' ? T['level'] : never : never
export type GetEvents<T extends any> = T extends Array<LogLevel | LogDefinition> ?
GetLogType<T[0]> | GetLogType<T[1]> | GetLogType<T[2]> | GetLogType<T[3]>
: never
export type QueryEvent = {
timestamp: Date
query: string
params: string
duration: number
target: string
}
export type LogEvent = {
timestamp: Date
message: string
target: string
}
/* End Types for Logging */
export type PrismaAction =
| 'findUnique'
| 'findMany'
| 'findFirst'
| 'create'
| 'createMany'
| 'update'
| 'updateMany'
| 'upsert'
| 'delete'
| 'deleteMany'
| 'executeRaw'
| 'queryRaw'
| 'aggregate'
| 'count'
/**
* These options are being passed in to the middleware as "params"
*/
export type MiddlewareParams = {
model?: ModelName
action: PrismaAction
args: any
dataPath: string[]
runInTransaction: boolean
}
/**
* The `T` type makes sure, that the `return proceed` is not forgotten in the middleware implementation
*/
export type Middleware<T = any> = (
params: MiddlewareParams,
next: (params: MiddlewareParams) => Promise<T>,
) => Promise<T>
// tested in getLogLevel.test.ts
export function getLogLevel(log: Array<LogLevel | LogDefinition>): LogLevel | undefined;
export type Datasource = {
url?: string
}
/**
* Count Types
*/
/**
* Models
*/
/**
* Model tables
*/
export type AggregateTables = {
_count: TablesCountAggregateOutputType | null
_avg: TablesAvgAggregateOutputType | null
_sum: TablesSumAggregateOutputType | null
_min: TablesMinAggregateOutputType | null
_max: TablesMaxAggregateOutputType | null
}
export type TablesAvgAggregateOutputType = {
id: number | null
}
export type TablesSumAggregateOutputType = {
id: number | null
}
export type TablesMinAggregateOutputType = {
id: number | null
name: string | null
}
export type TablesMaxAggregateOutputType = {
id: number | null
name: string | null
}
export type TablesCountAggregateOutputType = {
id: number
name: number
_all: number
}
export type TablesAvgAggregateInputType = {
id?: true
}
export type TablesSumAggregateInputType = {
id?: true
}
export type TablesMinAggregateInputType = {
id?: true
name?: true
}
export type TablesMaxAggregateInputType = {
id?: true
name?: true
}
export type TablesCountAggregateInputType = {
id?: true
name?: true
_all?: true
}
export type TablesAggregateArgs = {
/**
* Filter which tables to aggregate.
*
**/
where?: tablesWhereInput
/**
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
*
* Determine the order of tables to fetch.
*
**/
orderBy?: Enumerable<tablesOrderByWithRelationInput>
/**
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
*
* Sets the start position
*
**/
cursor?: tablesWhereUniqueInput
/**
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
*
* Take `±n` tables from the position of the cursor.
*
**/
take?: number
/**
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
*
* Skip the first `n` tables.
*
**/
skip?: number
/**
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
*
* Count returned tables
**/
_count?: true | TablesCountAggregateInputType
/**
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
*
* Select which fields to average
**/
_avg?: TablesAvgAggregateInputType
/**
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
*
* Select which fields to sum
**/
_sum?: TablesSumAggregateInputType
/**
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
*
* Select which fields to find the minimum value
**/
_min?: TablesMinAggregateInputType
/**
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
*
* Select which fields to find the maximum value
**/
_max?: TablesMaxAggregateInputType
}
export type GetTablesAggregateType<T extends TablesAggregateArgs> = {
[P in keyof T & keyof AggregateTables]: P extends '_count' | 'count'
? T[P] extends true
? number
: GetScalarType<T[P], AggregateTables[P]>
: GetScalarType<T[P], AggregateTables[P]>
}
export type TablesGroupByArgs = {
where?: tablesWhereInput
orderBy?: Enumerable<tablesOrderByWithAggregationInput>
by: Array<TablesScalarFieldEnum>
having?: tablesScalarWhereWithAggregatesInput
take?: number
skip?: number
_count?: TablesCountAggregateInputType | true
_avg?: TablesAvgAggregateInputType
_sum?: TablesSumAggregateInputType
_min?: TablesMinAggregateInputType
_max?: TablesMaxAggregateInputType
}
export type TablesGroupByOutputType = {
id: number
name: string | null
_count: TablesCountAggregateOutputType | null
_avg: TablesAvgAggregateOutputType | null
_sum: TablesSumAggregateOutputType | null
_min: TablesMinAggregateOutputType | null
_max: TablesMaxAggregateOutputType | null
}
type GetTablesGroupByPayload<T extends TablesGroupByArgs> = Promise<
Array<
PickArray<TablesGroupByOutputType, T['by']> &
{
[P in ((keyof T) & (keyof TablesGroupByOutputType))]: P extends '_count'
? T[P] extends boolean
? number
: GetScalarType<T[P], TablesGroupByOutputType[P]>
: GetScalarType<T[P], TablesGroupByOutputType[P]>
}
>
>
export type tablesSelect = {
id?: boolean
name?: boolean
}
export type tablesGetPayload<
S extends boolean | null | undefined | tablesArgs,
U = keyof S
> = S extends true
? tables
: S extends undefined
? never
: S extends tablesArgs | tablesFindManyArgs
?'include' extends U
? tables
: 'select' extends U
? {
[P in TrueKeys<S['select']>]: P extends keyof tables ?tables [P]
:
never
}
: tables
: tables
type tablesCountArgs = Merge<
Omit<tablesFindManyArgs, 'select' | 'include'> & {
select?: TablesCountAggregateInputType | true
}
>
export interface tablesDelegate<GlobalRejectSettings> {
/**
* Find zero or one Tables that matches the filter.
* @param {tablesFindUniqueArgs} args - Arguments to find a Tables
* @example
* // Get one Tables
* const tables = await prisma.tables.findUnique({
* where: {
* // ... provide filter here
* }
* })
**/
findUnique<T extends tablesFindUniqueArgs, LocalRejectSettings = T["rejectOnNotFound"] extends RejectOnNotFound ? T['rejectOnNotFound'] : undefined>(
args: SelectSubset<T, tablesFindUniqueArgs>
): HasReject<GlobalRejectSettings, LocalRejectSettings, 'findUnique', 'tables'> extends True ? CheckSelect<T, Prisma__tablesClient<tables>, Prisma__tablesClient<tablesGetPayload<T>>> : CheckSelect<T, Prisma__tablesClient<tables | null >, Prisma__tablesClient<tablesGetPayload<T> | null >>
/**
* Find the first Tables that matches the filter.
* Note, that providing `undefined` is treated as the value not being there.
* Read more here: https://pris.ly/d/null-undefined
* @param {tablesFindFirstArgs} args - Arguments to find a Tables
* @example
* // Get one Tables
* const tables = await prisma.tables.findFirst({
* where: {
* // ... provide filter here
* }
* })
**/
findFirst<T extends tablesFindFirstArgs, LocalRejectSettings = T["rejectOnNotFound"] extends RejectOnNotFound ? T['rejectOnNotFound'] : undefined>(
args?: SelectSubset<T, tablesFindFirstArgs>
): HasReject<GlobalRejectSettings, LocalRejectSettings, 'findFirst', 'tables'> extends True ? CheckSelect<T, Prisma__tablesClient<tables>, Prisma__tablesClient<tablesGetPayload<T>>> : CheckSelect<T, Prisma__tablesClient<tables | null >, Prisma__tablesClient<tablesGetPayload<T> | null >>
/**
* Find zero or more Tables that matches the filter.
* Note, that providing `undefined` is treated as the value not being there.
* Read more here: https://pris.ly/d/null-undefined
* @param {tablesFindManyArgs=} args - Arguments to filter and select certain fields only.
* @example
* // Get all Tables
* const tables = await prisma.tables.findMany()
*
* // Get first 10 Tables
* const tables = await prisma.tables.findMany({ take: 10 })
*
* // Only select the `id`
* const tablesWithIdOnly = await prisma.tables.findMany({ select: { id: true } })
*
**/
findMany<T extends tablesFindManyArgs>(
args?: SelectSubset<T, tablesFindManyArgs>
): CheckSelect<T, PrismaPromise<Array<tables>>, PrismaPromise<Array<tablesGetPayload<T>>>>
/**
* Create a Tables.
* @param {tablesCreateArgs} args - Arguments to create a Tables.
* @example
* // Create one Tables
* const Tables = await prisma.tables.create({
* data: {
* // ... data to create a Tables
* }
* })
*
**/
create<T extends tablesCreateArgs>(
args: SelectSubset<T, tablesCreateArgs>
): CheckSelect<T, Prisma__tablesClient<tables>, Prisma__tablesClient<tablesGetPayload<T>>>
/**
* Create many Tables.
* @param {tablesCreateManyArgs} args - Arguments to create many Tables.
* @example
* // Create many Tables
* const tables = await prisma.tables.createMany({
* data: {
* // ... provide data here
* }
* })
*
**/
createMany<T extends tablesCreateManyArgs>(
args?: SelectSubset<T, tablesCreateManyArgs>
): PrismaPromise<BatchPayload>
/**
* Delete a Tables.
* @param {tablesDeleteArgs} args - Arguments to delete one Tables.
* @example
* // Delete one Tables
* const Tables = await prisma.tables.delete({
* where: {
* // ... filter to delete one Tables
* }
* })
*
**/
delete<T extends tablesDeleteArgs>(
args: SelectSubset<T, tablesDeleteArgs>
): CheckSelect<T, Prisma__tablesClient<tables>, Prisma__tablesClient<tablesGetPayload<T>>>
/**
* Update one Tables.
* @param {tablesUpdateArgs} args - Arguments to update one Tables.
* @example
* // Update one Tables
* const tables = await prisma.tables.update({
* where: {
* // ... provide filter here
* },
* data: {
* // ... provide data here
* }
* })
*
**/
update<T extends tablesUpdateArgs>(
args: SelectSubset<T, tablesUpdateArgs>
): CheckSelect<T, Prisma__tablesClient<tables>, Prisma__tablesClient<tablesGetPayload<T>>>
/**
* Delete zero or more Tables.
* @param {tablesDeleteManyArgs} args - Arguments to filter Tables to delete.
* @example
* // Delete a few Tables
* const { count } = await prisma.tables.deleteMany({
* where: {
* // ... provide filter here
* }
* })
*
**/
deleteMany<T extends tablesDeleteManyArgs>(
args?: SelectSubset<T, tablesDeleteManyArgs>
): PrismaPromise<BatchPayload>
/**
* Update zero or more Tables.
* Note, that providing `undefined` is treated as the value not being there.
* Read more here: https://pris.ly/d/null-undefined
* @param {tablesUpdateManyArgs} args - Arguments to update one or more rows.
* @example
* // Update many Tables
* const tables = await prisma.tables.updateMany({
* where: {
* // ... provide filter here
* },
* data: {
* // ... provide data here
* }
* })
*
**/
updateMany<T extends tablesUpdateManyArgs>(
args: SelectSubset<T, tablesUpdateManyArgs>
): PrismaPromise<BatchPayload>
/**
* Create or update one Tables.
* @param {tablesUpsertArgs} args - Arguments to update or create a Tables.
* @example
* // Update or create a Tables
* const tables = await prisma.tables.upsert({
* create: {
* // ... data to create a Tables
* },
* update: {
* // ... in case it already exists, update
* },
* where: {
* // ... the filter for the Tables we want to update
* }
* })
**/
upsert<T extends tablesUpsertArgs>(
args: SelectSubset<T, tablesUpsertArgs>
): CheckSelect<T, Prisma__tablesClient<tables>, Prisma__tablesClient<tablesGetPayload<T>>>
/**
* Count the number of Tables.
* Note, that providing `undefined` is treated as the value not being there.
* Read more here: https://pris.ly/d/null-undefined
* @param {tablesCountArgs} args - Arguments to filter Tables to count.
* @example
* // Count the number of Tables
* const count = await prisma.tables.count({
* where: {
* // ... the filter for the Tables we want to count
* }
* })
**/
count<T extends tablesCountArgs>(
args?: Subset<T, tablesCountArgs>,
): PrismaPromise<
T extends _Record<'select', any>
? T['select'] extends true
? number
: GetScalarType<T['select'], TablesCountAggregateOutputType>
: number
>
/**
* Allows you to perform aggregations operations on a Tables.
* Note, that providing `undefined` is treated as the value not being there.
* Read more here: https://pris.ly/d/null-undefined
* @param {TablesAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
* @example
* // Ordered by age ascending
* // Where email contains prisma.io
* // Limited to the 10 users
* const aggregations = await prisma.user.aggregate({
* _avg: {
* age: true,
* },
* where: {
* email: {
* contains: "prisma.io",
* },
* },
* orderBy: {
* age: "asc",
* },
* take: 10,
* })
**/
aggregate<T extends TablesAggregateArgs>(args: Subset<T, TablesAggregateArgs>): PrismaPromise<GetTablesAggregateType<T>>
/**
* Group by Tables.
* Note, that providing `undefined` is treated as the value not being there.
* Read more here: https://pris.ly/d/null-undefined
* @param {TablesGroupByArgs} args - Group by arguments.
* @example
* // Group by city, order by createdAt, get count
* const result = await prisma.user.groupBy({
* by: ['city', 'createdAt'],
* orderBy: {
* createdAt: true
* },
* _count: {
* _all: true
* },
* })
*
**/
groupBy<
T extends TablesGroupByArgs,
HasSelectOrTake extends Or<
Extends<'skip', Keys<T>>,
Extends<'take', Keys<T>>
>,
OrderByArg extends True extends HasSelectOrTake
? { orderBy: TablesGroupByArgs['orderBy'] }
: { orderBy?: TablesGroupByArgs['orderBy'] },
OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
ByFields extends TupleToUnion<T['by']>,
ByValid extends Has<ByFields, OrderFields>,
HavingFields extends GetHavingFields<T['having']>,
HavingValid extends Has<ByFields, HavingFields>,
ByEmpty extends T['by'] extends never[] ? True : False,
InputErrors extends ByEmpty extends True
? `Error: "by" must not be empty.`
: HavingValid extends False
? {
[P in HavingFields]: P extends ByFields
? never
: P extends string
? `Error: Field "${P}" used in "having" needs to be provided in "by".`
: [
Error,
'Field ',
P,
` in "having" needs to be provided in "by"`,
]
}[HavingFields]
: 'take' extends Keys<T>
? 'orderBy' extends Keys<T>
? ByValid extends True
? {}
: {
[P in OrderFields]: P extends ByFields
? never
: `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
}[OrderFields]
: 'Error: If you provide "take", you also need to provide "orderBy"'
: 'skip' extends Keys<T>
? 'orderBy' extends Keys<T>
? ByValid extends True
? {}
: {
[P in OrderFields]: P extends ByFields
? never
: `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
}[OrderFields]
: 'Error: If you provide "skip", you also need to provide "orderBy"'
: ByValid extends True
? {}
: {
[P in OrderFields]: P extends ByFields
? never
: `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
}[OrderFields]
>(args: SubsetIntersection<T, TablesGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetTablesGroupByPayload<T> : Promise<InputErrors>
}
/**
* The delegate class that acts as a "Promise-like" for tables.
* Why is this prefixed with `Prisma__`?
* Because we want to prevent naming conflicts as mentioned in
* https://github.com/prisma/prisma-client-js/issues/707
*/
export class Prisma__tablesClient<T> implements PrismaPromise<T> {
[prisma]: true;
private readonly _dmmf;
private readonly _fetcher;
private readonly _queryType;
private readonly _rootField;
private readonly _clientMethod;
private readonly _args;
private readonly _dataPath;
private readonly _errorFormat;
private readonly _measurePerformance?;
private _isList;
private _callsite;
private _requestPromise?;
constructor(_dmmf: runtime.DMMFClass, _fetcher: PrismaClientFetcher, _queryType: 'query' | 'mutation', _rootField: string, _clientMethod: string, _args: any, _dataPath: string[], _errorFormat: ErrorFormat, _measurePerformance?: boolean | undefined, _isList?: boolean);
readonly [Symbol.toStringTag]: 'PrismaClientPromise';
private get _document();
/**
* Attaches callbacks for the resolution and/or rejection of the Promise.
* @param onfulfilled The callback to execute when the Promise is resolved.
* @param onrejected The callback to execute when the Promise is rejected.
* @returns A Promise for the completion of which ever callback is executed.
*/
then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
/**
* Attaches a callback for only the rejection of the Promise.
* @param onrejected The callback to execute when the Promise is rejected.
* @returns A Promise for the completion of the callback.
*/
catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<T | TResult>;
/**
* Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
* resolved value cannot be modified from the callback.
* @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
* @returns A Promise for the completion of the callback.
*/
finally(onfinally?: (() => void) | undefined | null): Promise<T>;
}
// Custom InputTypes
/**
* tables findUnique
*/
export type tablesFindUniqueArgs = {
/**
* Select specific fields to fetch from the tables
*
**/
select?: tablesSelect | null
/**
* Throw an Error if a tables can't be found
*
**/
rejectOnNotFound?: RejectOnNotFound
/**
* Filter, which tables to fetch.
*
**/
where: tablesWhereUniqueInput
}
/**
* tables findFirst
*/
export type tablesFindFirstArgs = {
/**
* Select specific fields to fetch from the tables
*
**/
select?: tablesSelect | null
/**
* Throw an Error if a tables can't be found
*
**/
rejectOnNotFound?: RejectOnNotFound
/**
* Filter, which tables to fetch.
*
**/
where?: tablesWhereInput
/**
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
*
* Determine the order of tables to fetch.
*
**/
orderBy?: Enumerable<tablesOrderByWithRelationInput>
/**
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
*
* Sets the position for searching for tables.
*
**/
cursor?: tablesWhereUniqueInput
/**
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
*
* Take `±n` tables from the position of the cursor.
*
**/
take?: number
/**
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
*
* Skip the first `n` tables.
*
**/
skip?: number
/**
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
*
* Filter by unique combinations of tables.
*
**/
distinct?: Enumerable<TablesScalarFieldEnum>
}
/**
* tables findMany
*/
export type tablesFindManyArgs = {
/**
* Select specific fields to fetch from the tables
*
**/
select?: tablesSelect | null
/**
* Filter, which tables to fetch.
*
**/
where?: tablesWhereInput
/**
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
*
* Determine the order of tables to fetch.
*
**/
orderBy?: Enumerable<tablesOrderByWithRelationInput>
/**
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
*
* Sets the position for listing tables.
*
**/
cursor?: tablesWhereUniqueInput
/**
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
*
* Take `±n` tables from the position of the cursor.
*
**/
take?: number
/**
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
*
* Skip the first `n` tables.
*
**/
skip?: number
distinct?: Enumerable<TablesScalarFieldEnum>
}
/**
* tables create
*/
export type tablesCreateArgs = {
/**
* Select specific fields to fetch from the tables
*
**/
select?: tablesSelect | null
/**
* The data needed to create a tables.
*
**/
data: XOR<tablesCreateInput, tablesUncheckedCreateInput>
}
/**
* tables createMany
*/
export type tablesCreateManyArgs = {
data: Enumerable<tablesCreateManyInput>
skipDuplicates?: boolean
}
/**
* tables update
*/
export type tablesUpdateArgs = {
/**
* Select specific fields to fetch from the tables
*
**/
select?: tablesSelect | null
/**
* The data needed to update a tables.
*
**/
data: XOR<tablesUpdateInput, tablesUncheckedUpdateInput>
/**
* Choose, which tables to update.
*
**/
where: tablesWhereUniqueInput
}
/**
* tables updateMany
*/
export type tablesUpdateManyArgs = {
data: XOR<tablesUpdateManyMutationInput, tablesUncheckedUpdateManyInput>
where?: tablesWhereInput
}
/**
* tables upsert
*/
export type tablesUpsertArgs = {
/**
* Select specific fields to fetch from the tables
*
**/
select?: tablesSelect | null
/**
* The filter to search for the tables to update in case it exists.
*
**/
where: tablesWhereUniqueInput
/**
* In case the tables found by the `where` argument doesn't exist, create a new tables with this data.
*
**/
create: XOR<tablesCreateInput, tablesUncheckedCreateInput>
/**
* In case the tables was found with the provided `where` argument, update it with this data.
*
**/
update: XOR<tablesUpdateInput, tablesUncheckedUpdateInput>
}
/**
* tables delete
*/
export type tablesDeleteArgs = {
/**
* Select specific fields to fetch from the tables
*
**/
select?: tablesSelect | null
/**
* Filter which tables to delete.
*
**/
where: tablesWhereUniqueInput
}
/**
* tables deleteMany
*/
export type tablesDeleteManyArgs = {
where?: tablesWhereInput
}
/**
* tables without action
*/
export type tablesArgs = {
/**
* Select specific fields to fetch from the tables
*
**/
select?: tablesSelect | null
}
/**
* Enums
*/
// Based on
// https://github.com/microsoft/TypeScript/issues/3192#issuecomment-261720275
export const TablesScalarFieldEnum: {
id: 'id',
name: 'name'
};
export type TablesScalarFieldEnum = (typeof TablesScalarFieldEnum)[keyof typeof TablesScalarFieldEnum]
export const SortOrder: {
asc: 'asc',
desc: 'desc'
};
export type SortOrder = (typeof SortOrder)[keyof typeof SortOrder]
export const QueryMode: {
default: 'default',
insensitive: 'insensitive'
};
export type QueryMode = (typeof QueryMode)[keyof typeof QueryMode]
/**
* Deep Input Types
*/
export type tablesWhereInput = {
AND?: Enumerable<tablesWhereInput>
OR?: Enumerable<tablesWhereInput>
NOT?: Enumerable<tablesWhereInput>
id?: IntFilter | number
name?: StringNullableFilter | string | null
}
export type tablesOrderByWithRelationInput = {
id?: SortOrder
name?: SortOrder
}
export type tablesWhereUniqueInput = {
id?: number
}
export type tablesOrderByWithAggregationInput = {
id?: SortOrder
name?: SortOrder
_count?: tablesCountOrderByAggregateInput
_avg?: tablesAvgOrderByAggregateInput
_max?: tablesMaxOrderByAggregateInput
_min?: tablesMinOrderByAggregateInput
_sum?: tablesSumOrderByAggregateInput
}
export type tablesScalarWhereWithAggregatesInput = {
AND?: Enumerable<tablesScalarWhereWithAggregatesInput>
OR?: Enumerable<tablesScalarWhereWithAggregatesInput>
NOT?: Enumerable<tablesScalarWhereWithAggregatesInput>
id?: IntWithAggregatesFilter | number
name?: StringNullableWithAggregatesFilter | string | null
}
export type tablesCreateInput = {
name?: string | null
}
export type tablesUncheckedCreateInput = {
id?: number
name?: string | null
}
export type tablesUpdateInput = {
name?: NullableStringFieldUpdateOperationsInput | string | null
}
export type tablesUncheckedUpdateInput = {
id?: IntFieldUpdateOperationsInput | number
name?: NullableStringFieldUpdateOperationsInput | string | null
}
export type tablesCreateManyInput = {
id?: number
name?: string | null
}
export type tablesUpdateManyMutationInput = {
name?: NullableStringFieldUpdateOperationsInput | string | null
}
export type tablesUncheckedUpdateManyInput = {
id?: IntFieldUpdateOperationsInput | number
name?: NullableStringFieldUpdateOperationsInput | string | null
}
export type IntFilter = {
equals?: number
in?: Enumerable<number>
notIn?: Enumerable<number>
lt?: number
lte?: number
gt?: number
gte?: number
not?: NestedIntFilter | number
}
export type StringNullableFilter = {
equals?: string | null
in?: Enumerable<string> | null
notIn?: Enumerable<string> | null
lt?: string
lte?: string
gt?: string
gte?: string
contains?: string
startsWith?: string
endsWith?: string
mode?: QueryMode
not?: NestedStringNullableFilter | string | null
}
export type tablesCountOrderByAggregateInput = {
id?: SortOrder
name?: SortOrder
}
export type tablesAvgOrderByAggregateInput = {
id?: SortOrder
}
export type tablesMaxOrderByAggregateInput = {
id?: SortOrder
name?: SortOrder
}
export type tablesMinOrderByAggregateInput = {
id?: SortOrder
name?: SortOrder
}
export type tablesSumOrderByAggregateInput = {
id?: SortOrder
}
export type IntWithAggregatesFilter = {
equals?: number
in?: Enumerable<number>
notIn?: Enumerable<number>
lt?: number
lte?: number
gt?: number
gte?: number
not?: NestedIntWithAggregatesFilter | number
_count?: NestedIntFilter
_avg?: NestedFloatFilter
_sum?: NestedIntFilter
_min?: NestedIntFilter
_max?: NestedIntFilter
}
export type StringNullableWithAggregatesFilter = {
equals?: string | null
in?: Enumerable<string> | null
notIn?: Enumerable<string> | null
lt?: string
lte?: string
gt?: string
gte?: string
contains?: string
startsWith?: string
endsWith?: string
mode?: QueryMode
not?: NestedStringNullableWithAggregatesFilter | string | null
_count?: NestedIntNullableFilter
_min?: NestedStringNullableFilter
_max?: NestedStringNullableFilter
}
export type NullableStringFieldUpdateOperationsInput = {
set?: string | null
}
export type IntFieldUpdateOperationsInput = {
set?: number
increment?: number
decrement?: number
multiply?: number
divide?: number
}
export type NestedIntFilter = {
equals?: number
in?: Enumerable<number>
notIn?: Enumerable<number>
lt?: number
lte?: number
gt?: number
gte?: number
not?: NestedIntFilter | number
}
export type NestedStringNullableFilter = {
equals?: string | null
in?: Enumerable<string> | null
notIn?: Enumerable<string> | null
lt?: string
lte?: string
gt?: string
gte?: string
contains?: string
startsWith?: string
endsWith?: string
not?: NestedStringNullableFilter | string | null
}
export type NestedIntWithAggregatesFilter = {
equals?: number
in?: Enumerable<number>
notIn?: Enumerable<number>
lt?: number
lte?: number
gt?: number
gte?: number
not?: NestedIntWithAggregatesFilter | number
_count?: NestedIntFilter
_avg?: NestedFloatFilter
_sum?: NestedIntFilter
_min?: NestedIntFilter
_max?: NestedIntFilter
}
export type NestedFloatFilter = {
equals?: number
in?: Enumerable<number>
notIn?: Enumerable<number>
lt?: number
lte?: number
gt?: number
gte?: number
not?: NestedFloatFilter | number
}
export type NestedStringNullableWithAggregatesFilter = {
equals?: string | null
in?: Enumerable<string> | null
notIn?: Enumerable<string> | null
lt?: string
lte?: string
gt?: string
gte?: string
contains?: string
startsWith?: string
endsWith?: string
not?: NestedStringNullableWithAggregatesFilter | string | null
_count?: NestedIntNullableFilter
_min?: NestedStringNullableFilter
_max?: NestedStringNullableFilter
}
export type NestedIntNullableFilter = {
equals?: number | null
in?: Enumerable<number> | null
notIn?: Enumerable<number> | null
lt?: number
lte?: number
gt?: number
gte?: number
not?: NestedIntNullableFilter | number | null
}
/**
* Batch Payload for updateMany & deleteMany & createMany
*/
export type BatchPayload = {
count: number
}
/**
* DMMF
*/
export const dmmf: runtime.DMMF.Document;
}
Generated Scala Code
package typings.generatedPrismaClient.mod.Prisma
import typings.generatedPrismaClient.generatedPrismaClientStrings.PrismaClientPromise
import typings.generatedPrismaClient.generatedPrismaClientStrings.mutation
import typings.generatedPrismaClient.generatedPrismaClientStrings.query
import typings.generatedPrismaClient.mod.PrismaPromise
import typings.generatedPrismaClient.runtimeMod.DMMFClass
import org.scalablytyped.runtime.StObject
import scala.scalajs.js
import scala.scalajs.js.`|`
import scala.scalajs.js.annotation.{JSGlobalScope, JSGlobal, JSImport, JSName, JSBracketAccess}
@JSImport("generated-prisma-client", "Prisma.Prisma__tablesClient")
@js.native
class PrismaTablesClient[T] protected () extends PrismaPromise[T] {
def this(
_dmmf: DMMFClass,
_fetcher: PrismaClientFetcher,
_queryType: query | mutation,
_rootField: String,
_clientMethod: String,
_args: Any,
_dataPath: js.Array[String],
_errorFormat: ErrorFormat
) = this()
def this(
_dmmf: DMMFClass,
_fetcher: PrismaClientFetcher,
_queryType: query | mutation,
_rootField: String,
_clientMethod: String,
_args: Any,
_dataPath: js.Array[String],
_errorFormat: ErrorFormat,
_measurePerformance: scala.Boolean
) = this()
def this(
_dmmf: DMMFClass,
_fetcher: PrismaClientFetcher,
_queryType: query | mutation,
_rootField: String,
_clientMethod: String,
_args: Any,
_dataPath: js.Array[String],
_errorFormat: ErrorFormat,
_measurePerformance: scala.Boolean,
_isList: scala.Boolean
) = this()
def this(
_dmmf: DMMFClass,
_fetcher: PrismaClientFetcher,
_queryType: query | mutation,
_rootField: String,
_clientMethod: String,
_args: Any,
_dataPath: js.Array[String],
_errorFormat: ErrorFormat,
_measurePerformance: Unit,
_isList: scala.Boolean
) = this()
/* private */ val _args: Any = js.native
/* private */ var _callsite: Any = js.native
/* private */ val _clientMethod: Any = js.native
/* private */ val _dataPath: Any = js.native
/* private */ val _dmmf: Any = js.native
/* private */ def _document: Any = js.native
/* private */ val _errorFormat: Any = js.native
/* private */ val _fetcher: Any = js.native
/* private */ var _isList: Any = js.native
/* private */ val _measurePerformance: Any = js.native
/* private */ val _queryType: Any = js.native
/* private */ var _requestPromise: Any = js.native
/* private */ val _rootField: Any = js.native
/**
* Attaches a callback for only the rejection of the Promise.
* @param onrejected The callback to execute when the Promise is rejected.
* @returns A Promise for the completion of the callback.
*/
def `catch`[TResult](): js.Promise[T | TResult] = js.native
def `catch`[TResult](onrejected: js.Function1[/* reason */ Any, TResult | js.Thenable[TResult]]): js.Promise[T | TResult] = js.native
/**
* Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
* resolved value cannot be modified from the callback.
* @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
* @returns A Promise for the completion of the callback.
*/
def `finally`(): js.Promise[T] = js.native
def `finally`(onfinally: js.Function0[Unit]): js.Promise[T] = js.native
/**
* Attaches callbacks for the resolution and/or rejection of the Promise.
* @param onfulfilled The callback to execute when the Promise is resolved.
* @param onrejected The callback to execute when the Promise is rejected.
* @returns A Promise for the completion of which ever callback is executed.
*/
def `then`[TResult1, TResult2](): js.Promise[TResult1 | TResult2] = js.native
def `then`[TResult1, TResult2](onfulfilled: js.Function1[/* value */ T, TResult1 | js.Thenable[TResult1]]): js.Promise[TResult1 | TResult2] = js.native
def `then`[TResult1, TResult2](
onfulfilled: js.Function1[/* value */ T, TResult1 | js.Thenable[TResult1]],
onrejected: js.Function1[/* reason */ Any, TResult2 | js.Thenable[TResult2]]
): js.Promise[TResult1 | TResult2] = js.native
def `then`[TResult1, TResult2](onfulfilled: Null, onrejected: js.Function1[/* reason */ Any, TResult2 | js.Thenable[TResult2]]): js.Promise[TResult1 | TResult2] = js.native
def `then`[TResult1, TResult2](onfulfilled: Unit, onrejected: js.Function1[/* reason */ Any, TResult2 | js.Thenable[TResult2]]): js.Promise[TResult1 | TResult2] = js.native
@JSName(js.Symbol.toStringTag)
val toStringTag: PrismaClientPromise = js.native
}
@oyvindberg I'm trying to follow https://scalablytyped.org/docs/import-problems. But when trying to run the tests as stated in the docs, nothing is running. Any hint?
root> testOnly org.scalablytyped.converter.internal.importer.ImporterTest
[info] Passed: Total 0, Failed 0, Errors 0, Passed 0
[info] No tests to run for logging / Test / testOnly
[info] Passed: Total 0, Failed 0, Errors 0, Passed 0
[info] Passed: Total 0, Failed 0, Errors 0, Passed 0
[info] No tests to run for core / Test / testOnly
[info] No tests to run for Test / testOnly
[info] Passed: Total 0, Failed 0, Errors 0, Passed 0
[info] No tests to run for scalajs / Test / testOnly
[info] Passed: Total 0, Failed 0, Errors 0, Passed 0
[info] No tests to run for ts / Test / testOnly
[info] Passed: Total 0, Failed 0, Errors 0, Passed 0
[info] No tests to run for phases / Test / testOnly
[info] Passed: Total 0, Failed 0, Errors 0, Passed 0
[info] No tests to run for importer-portable / Test / testOnly
[info] Passed: Total 0, Failed 0, Errors 0, Passed 0
[info] No tests to run for sbt-converter / Test / testOnly
[info] Passed: Total 0, Failed 0, Errors 0, Passed 0
[info] No tests to run for importer / Test / testOnly
[info] Passed: Total 0, Failed 0, Errors 0, Passed 0
[info] No tests to run for cli / Test / testOnly
[success] Total time: 0 s, completed Jan 27, 2022, 12:10:22 PM
Ok... Running it in Ubuntu with java 1.8 and testOnly org.scalablytyped.converter.internal.importer.ImporterTest213 finally does something. I think I can work with that.
Hey there. Sorry I've been a bit unresponsive, plenty of other things going on as well :) Thanks for detailed report and looking into fixing this :)
I'll try to respond in order:
js.Promise missing nullary constructor
This problem is something that I've seen before. The encoding ST uses for the generated scala code relies on classes having a (potentially protected) nullary constructor. You see this in the code you posted:
// primary, nullary constructor used for inheritance
class PrismaTablesClient[T] protected () extends PrismaPromise[T] {
// secondary, public constructors
def this(
_dmmf: DMMFClass,
// ...
) = this()
}
If a class does not have such a nullary constructor you'll get an error like the one you saw when you try to inherit from it
not enough arguments for constructor Promise: (executor: scala.scalajs.js.Function2[scala.scalajs.js.Function1[T | scala.scalajs.js.Thenable[T], _], scala.scalajs.js.Function1[Any, _], _]): scala.scalajs.js.Promise[T].
This is made more difficult to follow by the intermediate type PrismaPromise. So the problem is that js.Promise doesn't have such a constructor. There are some hacks in the ST codebase to use js.Thenable in inheritance clauses to work around this, but that approach doesn't work with PrismaPromise inbetween.
What can I do to try fixing this myself?
The proper fix for this issue is to PR such a constructor to upstream so we can freely inherit from it. Also pray that it's backwards compatible change, I think it is.
tests
root> testOnly org.scalablytyped.converter.internal.importer.ImporterTest
This was written before scala 3 support was added. now that test is a trait with two concrete implementations, ImporterTest213 and ImporterTest3. These tests are snapshot tests, that is they generate a lot of code, compile it, and all that code is checked in. CI then checks that the generated checked in code matches what is generated when running the test. As such this covers a whole lot of ground, testing wise. I think snapshot tests are incredibly powerful, and allows me to test so much with so little effort.
ImporterTest213 is kept around to ensure that code still compiles for Scala 2.13, but the results are not checked in.
workaround
to unblock yourself to test the generated library you can change the generated source code to something which compiles, and publishLocal it. The generated code is put within target/streams/_global/stImport/_global/streams/sources/g/generated-prisma-client, you can open it with say intellij as an sbt project. You can also use library mode and pretty much do the same thing.
