@augment-vir/common 30.0.1 → 30.0.2

package/dist/augments/array/array-to-object.d.ts

@@ -1,3 +1,4 @@
+import { MaybePromise } from '@augment-vir/core';
 /**
  * Polyfill for `Object.groupBy`:
  * https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/groupBy
@@ -20,34 +21,15 @@
  * ```
  */
 export declare function groupArrayBy<ElementType, NewKey extends PropertyKey>(inputArray: ReadonlyArray<ElementType>, callback: (value: ElementType, index: number, originalArray: ReadonlyArray<ElementType>) => NewKey): Partial<Record<NewKey, ElementType[]>>;
-/**
- * Similar to {@link groupArrayBy} but maps array entries to a single key and requires `key` _and_
- * `value` outputs from the callback. The resulting object does not have an array of elements
- * (unless the original array itself contains arrays).
- *
- * @category Array
- * @category Object
- * @category Package : @augment-vir/common
- * @example
- *
- * ```ts
- * import {arrayToObject} from '@augment-vir/common';
- *
- * const result = arrayToObject(
- *     [
- *         'a',
- *         'b',
- *     ],
- *     (value) => {
- *         return {key: `key-${value}`, value};
- *     },
- * );
- * // result is `{key-a: 'a', key-b: 'b'}`
- * ```
- *
- * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
- */
+export declare function arrayToObject<ElementType, NewKey extends PropertyKey, NewValue>(inputArray: ReadonlyArray<ElementType>, callback: (value: ElementType, index: number, originalArray: ReadonlyArray<ElementType>) => Promise<{
+    key: NewKey;
+    value: NewValue;
+} | undefined>): Promise<Partial<Record<NewKey, NewValue>>>;
 export declare function arrayToObject<ElementType, NewKey extends PropertyKey, NewValue>(inputArray: ReadonlyArray<ElementType>, callback: (value: ElementType, index: number, originalArray: ReadonlyArray<ElementType>) => {
     key: NewKey;
     value: NewValue;
-}): Partial<Record<NewKey, NewValue>>;
+} | undefined): Partial<Record<NewKey, NewValue>>;
+export declare function arrayToObject<ElementType, NewKey extends PropertyKey, NewValue>(inputArray: ReadonlyArray<ElementType>, callback: (value: ElementType, index: number, originalArray: ReadonlyArray<ElementType>) => MaybePromise<{
+    key: NewKey;
+    value: NewValue;
+} | undefined>): MaybePromise<Partial<Record<NewKey, NewValue>>>;

package/dist/augments/array/array-to-object.js

@@ -1,5 +1,8 @@
+import { check } from '@augment-vir/assert';
+import { ensureError } from '@augment-vir/core';
 import { getOrSet } from '../object/get-or-set.js';
 import { typedObjectFromEntries } from '../object/object-entries.js';
+import { filterMap } from './filter.js';
 /**
  * Polyfill for `Object.groupBy`:
  * https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/groupBy
@@ -32,7 +35,8 @@ export function groupArrayBy(inputArray, callback) {
 /**
  * Similar to {@link groupArrayBy} but maps array entries to a single key and requires `key` _and_
  * `value` outputs from the callback. The resulting object does not have an array of elements
- * (unless the original array itself contains arrays).
+ * (unless the original array itself contains arrays). Automatically handles the case where the
+ * callback returns a promise.
  *
  * @category Array
  * @category Object
@@ -57,11 +61,55 @@ export function groupArrayBy(inputArray, callback) {
  * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
  */
 export function arrayToObject(inputArray, callback) {
-    return typedObjectFromEntries(inputArray.map((entry, index, originalArray) => {
-        const { key, value } = callback(entry, index, originalArray);
-        return [
-            key,
-            value,
-        ];
-    }));
+    try {
+        let gotAPromise = false;
+        const mappedEntries = inputArray
+            .map((entry, index, originalArray) => {
+            const output = callback(entry, index, originalArray);
+            if (output instanceof Promise) {
+                gotAPromise = true;
+                return output;
+            }
+            else if (output) {
+                return [
+                    output.key,
+                    output.value,
+                ];
+            }
+            else {
+                return undefined;
+            }
+        })
+            .filter(check.isTruthy);
+        if (gotAPromise) {
+            return new Promise(async (resolve, reject) => {
+                try {
+                    const entries = filterMap(await Promise.all(mappedEntries), (entry) => {
+                        if (!entry) {
+                            return undefined;
+                        }
+                        else if (Array.isArray(entry)) {
+                            return entry;
+                        }
+                        else {
+                            return [
+                                entry.key,
+                                entry.value,
+                            ];
+                        }
+                    }, check.isTruthy);
+                    resolve(typedObjectFromEntries(entries));
+                }
+                catch (error) {
+                    reject(ensureError(error));
+                }
+            });
+        }
+        else {
+            return typedObjectFromEntries(mappedEntries);
+        }
+    }
+    catch (error) {
+        throw ensureError(error);
+    }
 }

package/dist/augments/prisma/base-prisma-types.d.ts

@@ -0,0 +1,38 @@
+import { AnyObject, type AnyFunction } from '@augment-vir/core';
+/**
+ * A base type for Prisma model payloads because Prisma doesn't give us one. This currently only
+ * includes the properties that are used within this package.
+ *
+ * Note: this omits the `composites` property because I don't have any examples of what those
+ * actually are.
+ *
+ * @category Prisma : Common
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type BasePrismaPayload = {
+    name: string;
+    objects: Record<string, BasePrismaPayload | BasePrismaPayload[] | null>;
+    scalars: AnyObject;
+};
+/**
+ * Base Prisma client type that all `PrismaClient` instances should be able to match, with enough
+ * data that it'll omit random accidental objects.
+ *
+ * @category Prisma : Common
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type BasePrismaClient = {
+    $connect: AnyFunction;
+    $disconnect: AnyFunction;
+    $executeRaw: AnyFunction;
+    $executeRawUnsafe: AnyFunction;
+    $extends: AnyFunction;
+    $on: AnyFunction;
+    $queryRaw: AnyFunction;
+    $queryRawUnsafe: AnyFunction;
+    $transaction: AnyFunction;
+} & {
+    [ModelName in string]: any;
+};

package/dist/augments/prisma/prisma-basic-model.d.ts

@@ -0,0 +1,29 @@
+import type { BasePrismaClient } from './base-prisma-types.js';
+import type { PrismaModelName } from './prisma-model-name.js';
+/**
+ * A basic model entry with only its immediate properties.
+ *
+ * @category Prisma : Common
+ * @category Package : @augment-vir/common
+ * @example
+ *
+ * ```ts
+ * import type {PrismaClient} from '@prisma/client';
+ * import type {PrismaBasicModel} from '@augment-vir/common';
+ *
+ * function doThing(fullModel: PrismaBasicModel<PrismaClient, 'user'>) {}
+ * ```
+ *
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type PrismaBasicModel<PrismaClient extends BasePrismaClient, Model extends PrismaModelName<PrismaClient>> = PrismaClient['model'][Model]['payload']['scalars'];
+/**
+ * Basic model entries for all models in the database.
+ *
+ * @category Prisma : Common
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type PrismaAllBasicModels<PrismaClient extends BasePrismaClient> = Partial<{
+    [ModelName in PrismaModelName<PrismaClient>]: PrismaBasicModel<PrismaClient, ModelName>[];
+}>;

package/dist/augments/prisma/prisma-basic-model.js

@@ -0,0 +1 @@
+export {};

package/dist/augments/prisma/prisma-full-model.d.ts

@@ -0,0 +1,37 @@
+import { type BasePrismaClient, type BasePrismaPayload } from './base-prisma-types.js';
+import type { PrismaModelName } from './prisma-model-name.js';
+/**
+ * A full model entry with all relations from the given Prisma type map and model name.
+ *
+ * @category Prisma : Common
+ * @category Package : @augment-vir/common
+ * @example
+ *
+ * ```ts
+ * import type {Prisma} from '@prisma/client';
+ * import type {FullPrismaModel} from '@augment-vir/common';
+ *
+ * function doThing(fullModel: FullModel<Prisma.TypeMap, 'User'>) {}
+ * ```
+ *
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type PrismaFullModel<PrismaClient extends BasePrismaClient, Model extends PrismaModelName<PrismaClient>> = ExpandPrismaTypeMapPayload<PrismaClient[Model][symbol]['types']['payload']>;
+/**
+ * Expand a Prisma payload into its scalars and recursive relations.
+ *
+ * @category Prisma : Common : Util
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type ExpandPrismaTypeMapPayload<Payload extends BasePrismaPayload> = Payload['scalars'] & {
+    [Key in keyof Payload['objects']]: ExpandPotentialArrayPrismaTypeMapPayload<NonNullable<Payload['objects'][Key]>> | (null extends Payload['objects'][Key] ? null : never);
+};
+/**
+ * Expand a payload that might be inside of an array, keeping it inside of an array if it is.
+ *
+ * @category Prisma : Common : Util
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type ExpandPotentialArrayPrismaTypeMapPayload<PayloadWrapper extends BasePrismaPayload | BasePrismaPayload[]> = PayloadWrapper extends (infer ActualPayload extends BasePrismaPayload)[] ? ExpandPrismaTypeMapPayload<ActualPayload>[] : PayloadWrapper extends BasePrismaPayload ? ExpandPrismaTypeMapPayload<PayloadWrapper> : never;

package/dist/augments/prisma/prisma-full-model.js

@@ -0,0 +1 @@
+export {};

package/dist/augments/prisma/prisma-model-create.d.ts

@@ -0,0 +1,159 @@
+import type { BasePrismaClient } from './base-prisma-types.js';
+import type { PrismaModelName } from './prisma-model-name.js';
+/**
+ * Use this to define mock entries that _shouldn't_ be saved to the database so that we can easily
+ * write tests for missing data.
+ *
+ * @category Prisma : Common
+ * @category Package : @augment-vir/common
+ * @example
+ *
+ * ```ts
+ * import type {PrismaClient} from '@prisma/client';
+ * import {prismaModelCreateExclude, PrismaKeyedModelCreate} from '@augment-vir/common';
+ *
+ * export const mockUsers = {
+ *     user1: {
+ *         id: 1,
+ *         authRole: 'admin',
+ *     },
+ *     missingUser: {
+ *         id: -1,
+ *         authRole: 'user',
+ *         [prismaModelCreateExclude]: true,
+ *     },
+ * } as const satisfies PrismaKeyedModelCreate<PrismaClient, 'User'>;
+ * ```
+ *
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export declare const prismaModelCreateExclude: unique symbol;
+/**
+ * Use this to prevent the id property from being included when creating a mock record, allowing the
+ * database's internal auto-increment functionality to generate one. This is necessary when testing
+ * creation of new records because manually specified ids do not increment the auto incrementor.
+ *
+ * @category Prisma : Common
+ * @category Package : @augment-vir/common
+ * @example
+ *
+ * ```ts
+ * import type {PrismaClient} from '@prisma/client';
+ * import {prismaModelCreateOmitId, PrismaKeyedModelCreate} from '@augment-vir/common';
+ *
+ * export const mockUsers = {
+ *     user1: {
+ *         id: 1,
+ *         authRole: 'admin',
+ *         [prismaModelCreateOmitId]: true,
+ *     },
+ *     user2: {
+ *         id: 2,
+ *         authRole: 'admin',
+ *         [prismaModelCreateOmitId]: true,
+ *     },
+ * } as const satisfies PrismaKeyedModelCreate<PrismaClient, 'User'>;
+ * ```
+ *
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export declare const prismaModelCreateOmitId: unique symbol;
+/**
+ * Extracts the creation data for a model from the given `PrismaClient` type.
+ *
+ * @category Prisma : Common
+ * @category Package : @augment-vir/common
+ * @example
+ *
+ * ```ts
+ * import type {PrismaClient} from '@prisma/client';
+ * import type {PrismaModelCreate} from '@augment-vir/common';
+ *
+ * function doThing(entry: PrismaModelCreate<PrismaClient, 'User'>) {}
+ * ```
+ *
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type PrismaModelCreate<PrismaClient extends BasePrismaClient, Model extends PrismaModelName<PrismaClient>> = NonNullable<Parameters<PrismaClient[Model]['create']>[0]> extends {
+    data?: infer Data;
+} ? NonNullable<Data> & Partial<{
+    [prismaModelCreateExclude]: true;
+    [prismaModelCreateOmitId]: true;
+}> : `ERROR: failed to infer creation entry for model '${Model}'`;
+/**
+ * A type for creating multiple Prisma create mocks that are named for future reference.
+ *
+ * @category Prisma : Common
+ * @category Package : @augment-vir/common
+ * @example
+ *
+ * ```ts
+ * import {PrismaKeyedModelCreate} from '@augment-vir/common';
+ * import type {PrismaClient} from '@prisma/client';
+ *
+ * const mockUsers = {
+ *     mockUser1: {
+ *         first_name: 'one',
+ *         id: 123,
+ *         // etc.
+ *     },
+ *     mockUser2: {
+ *         first_name: 'two',
+ *         id: 124,
+ *         auth_role: 'user',
+ *         // etc.
+ *     },
+ * } as const satisfies PrismaKeyedModelCreate<PrismaClient, 'User'>;
+ * ```
+ *
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type PrismaKeyedModelCreate<PrismaClient extends BasePrismaClient, Model extends PrismaModelName<PrismaClient>> = {
+    [EntryName in string]: PrismaModelCreate<PrismaClient, Model>;
+};
+/**
+ * Model create data stored by model name in either array or keyed form. Used in
+ * `prisma.client.addData()` from `@augment-vir/node`.
+ *
+ * @category Prisma : Common
+ * @category Package : @augment-vir/common
+ * @example
+ *
+ * ```ts
+ * import {PrismaKeyedModelCreate} from '@augment-vir/common';
+ * import type {PrismaClient} from '@prisma/client';
+ *
+ * const mockData: ModelCreateData<PrismaClient> = {
+ *     user: {
+ *         mockUser1: {
+ *             first_name: 'one',
+ *             id: 123,
+ *             // etc.
+ *         },
+ *         mockUser2: {
+ *             first_name: 'two',
+ *             id: 124,
+ *             auth_role: 'user',
+ *             // etc.
+ *         },
+ *     },
+ *     region: [
+ *         {
+ *             id: 1,
+ *             name: 'North America',
+ *             // etc.
+ *         },
+ *         {
+ *             id: 2,
+ *             name: 'Europe',
+ *             // etc.
+ *         },
+ *     ],
+ * };
+ * ```
+ *
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type PrismaAllModelsCreate<PrismaClient extends BasePrismaClient> = Readonly<Partial<{
+    [Model in PrismaModelName<PrismaClient>]: Readonly<PrismaKeyedModelCreate<PrismaClient, Model>> | ReadonlyArray<Readonly<PrismaModelCreate<PrismaClient, Model>>>;
+}>>;

package/dist/augments/prisma/prisma-model-create.js

@@ -0,0 +1,58 @@
+/**
+ * Use this to define mock entries that _shouldn't_ be saved to the database so that we can easily
+ * write tests for missing data.
+ *
+ * @category Prisma : Common
+ * @category Package : @augment-vir/common
+ * @example
+ *
+ * ```ts
+ * import type {PrismaClient} from '@prisma/client';
+ * import {prismaModelCreateExclude, PrismaKeyedModelCreate} from '@augment-vir/common';
+ *
+ * export const mockUsers = {
+ *     user1: {
+ *         id: 1,
+ *         authRole: 'admin',
+ *     },
+ *     missingUser: {
+ *         id: -1,
+ *         authRole: 'user',
+ *         [prismaModelCreateExclude]: true,
+ *     },
+ * } as const satisfies PrismaKeyedModelCreate<PrismaClient, 'User'>;
+ * ```
+ *
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export const prismaModelCreateExclude = Symbol('prisma-model-create-exclude');
+/**
+ * Use this to prevent the id property from being included when creating a mock record, allowing the
+ * database's internal auto-increment functionality to generate one. This is necessary when testing
+ * creation of new records because manually specified ids do not increment the auto incrementor.
+ *
+ * @category Prisma : Common
+ * @category Package : @augment-vir/common
+ * @example
+ *
+ * ```ts
+ * import type {PrismaClient} from '@prisma/client';
+ * import {prismaModelCreateOmitId, PrismaKeyedModelCreate} from '@augment-vir/common';
+ *
+ * export const mockUsers = {
+ *     user1: {
+ *         id: 1,
+ *         authRole: 'admin',
+ *         [prismaModelCreateOmitId]: true,
+ *     },
+ *     user2: {
+ *         id: 2,
+ *         authRole: 'admin',
+ *         [prismaModelCreateOmitId]: true,
+ *     },
+ * } as const satisfies PrismaKeyedModelCreate<PrismaClient, 'User'>;
+ * ```
+ *
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export const prismaModelCreateOmitId = Symbol('prisma-model-create-exclude-id');

package/dist/augments/prisma/prisma-model-name.d.ts

@@ -0,0 +1,18 @@
+import { BasePrismaClient } from './base-prisma-types.js';
+/**
+ * Extracts all model names from a generated `PrismaClient`.
+ *
+ * @category Prisma : Common
+ * @category Package : @augment-vir/common
+ * @example
+ *
+ * ```ts
+ * import type {PrismaClient} from '@prisma/client';
+ * import type {PrismaModelName} from '@augment-vir/common';
+ *
+ * function doThing(modelName: PrismaModelName<PrismaClient>) {}
+ * ```
+ *
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type PrismaModelName<PrismaClient extends BasePrismaClient> = Exclude<keyof PrismaClient, `$${string}` | symbol>;

package/dist/augments/prisma/prisma-model-name.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -51,7 +51,11 @@ export * from './augments/object/object-filter.js';
 export * from './augments/object/object-keys.js';
 export * from './augments/object/object-values.js';
 export * from './augments/path/esm-path.js';
-export * from './augments/prisma/prisma-models.js';
+export * from './augments/prisma/base-prisma-types.js';
+export * from './augments/prisma/prisma-basic-model.js';
+export * from './augments/prisma/prisma-full-model.js';
+export * from './augments/prisma/prisma-model-create.js';
+export * from './augments/prisma/prisma-model-name.js';
 export * from './augments/promise/timed-promise.js';
 export * from './augments/random/random-boolean.js';
 export * from './augments/random/random-integer.js';

package/dist/index.js

@@ -51,7 +51,11 @@ export * from './augments/object/object-filter.js';
 export * from './augments/object/object-keys.js';
 export * from './augments/object/object-values.js';
 export * from './augments/path/esm-path.js';
-export * from './augments/prisma/prisma-models.js';
+export * from './augments/prisma/base-prisma-types.js';
+export * from './augments/prisma/prisma-basic-model.js';
+export * from './augments/prisma/prisma-full-model.js';
+export * from './augments/prisma/prisma-model-create.js';
+export * from './augments/prisma/prisma-model-name.js';
 export * from './augments/promise/timed-promise.js';
 export * from './augments/random/random-boolean.js';
 export * from './augments/random/random-integer.js';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@augment-vir/common",
-    "version": "30.0.1",
+    "version": "30.0.2",
     "description": "A collection of augments, helpers types, functions, and classes for any JavaScript environment.",
     "keywords": [
         "augment",
@@ -39,20 +39,20 @@
         "test:web": "virmator --no-deps test web"
     },
     "dependencies": {
-        "@augment-vir/assert": "^30.0.1",
-        "@augment-vir/core": "^30.0.1",
+        "@augment-vir/assert": "^30.0.2",
+        "@augment-vir/core": "^30.0.2",
         "@date-vir/duration": "^6.0.0",
         "ansi-styles": "^6.2.1",
         "json5": "^2.2.3",
-        "type-fest": "^4.25.0"
+        "type-fest": "^4.26.1"
     },
     "devDependencies": {
         "@web/dev-server-esbuild": "^1.0.2",
-        "@web/test-runner": "^0.18.3",
+        "@web/test-runner": "^0.19.0",
         "@web/test-runner-commands": "^0.9.0",
         "@web/test-runner-playwright": "^0.11.0",
-        "@web/test-runner-visual-regression": "^0.9.0",
-        "concurrently": "^8.2.2",
+        "@web/test-runner-visual-regression": "^0.10.0",
+        "concurrently": "^9.0.0",
         "execute-in-browser": "^1.0.3",
         "istanbul-smart-text-reporter": "^1.1.4"
     },

package/dist/augments/prisma/prisma-models.d.ts

@@ -1,143 +0,0 @@
-import type { AnyFunction, AnyObject } from '@augment-vir/core';
-/**
- * Extracts all model names from a generated `Prisma` object.
- *
- * @category Prisma : Common
- * @category Package : @augment-vir/common
- * @example
- *
- * ```ts
- * import type {Prisma} from '@prisma/client';
- * import type {ModelNameFromPrismaTypeMap} from '@augment-vir/common';
- *
- * function doThing(modelName: ModelNameFromPrismaTypeMap<Prisma.TypeMap>) {}
- * ```
- *
- * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
- */
-export type ModelNameFromPrismaTypeMap<PrismaTypeMap extends BasePrismaTypeMap> = PrismaTypeMap['meta']['modelProps'];
-/**
- * Extracts all model names from a generated `PrismaClient`.
- *
- * @category Prisma : Common
- * @category Package : @augment-vir/common
- * @example
- *
- * ```ts
- * import type {PrismaClient} from '@prisma/client';
- * import type {ModelNameFromPrismaClient} from '@augment-vir/common';
- *
- * function doThing(modelName: ModelNameFromPrismaClient<PrismaClient>) {}
- * ```
- *
- * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
- */
-export type ModelNameFromPrismaClient<PrismaClient extends AnyObject> = keyof {
-    [Model in Extract<keyof PrismaClient, string> as PrismaClient[Model] extends {
-        findFirst: AnyFunction;
-    } ? Model : never]: boolean;
-};
-/**
- * Extracts the creation data for a model from the given `PrismaClient` type.
- *
- * @category Prisma : Common
- * @category Package : @augment-vir/common
- * @example
- *
- * ```ts
- * import type {PrismaClient} from '@prisma/client';
- * import type {ModelCreationEntry} from '@augment-vir/common';
- *
- * function doThing(entry: ModelCreationEntry<PrismaClient, 'User'>) {}
- * ```
- *
- * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
- */
-export type PrismaModelCreationEntry<PrismaClient extends AnyObject, Model extends ModelNameFromPrismaClient<PrismaClient>> = NonNullable<Parameters<PrismaClient[Model]['create']>[0]> extends {
-    data?: infer Data;
-} ? NonNullable<Data> : `ERROR: failed to infer creation entry for model '${Model}'`;
-/**
- * A base type for `Prisma.TypeMap` because Prisma doesn't give us one. This currently only includes
- * the properties that are used within `@augment-vir/common`.
- *
- * @category Prisma : Common
- * @category Package : @augment-vir/common
- * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
- */
-export type BasePrismaTypeMap = {
-    meta: {
-        modelProps: string;
-    };
-    model: Record<string, {
-        payload: BasePrismaPayload;
-    }>;
-};
-/**
- * A base type for Prisma model payloads because Prisma doesn't give us one. This currently only
- * includes the properties that are used within this package.
- *
- * Note: this omits the `composites` property because I don't have any examples of what those
- * actually are.
- *
- * @category Prisma : Common
- * @category Package : @augment-vir/common
- * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
- */
-export type BasePrismaPayload = {
-    name: string;
-    objects: Record<string, BasePrismaPayload | BasePrismaPayload[] | null>;
-    scalars: AnyObject;
-};
-/**
- * A full model entry with all relations from the given Prisma type map and model name.
- *
- * @category Prisma : Common
- * @category Package : @augment-vir/common
- * @example
- *
- * ```ts
- * import type {Prisma} from '@prisma/client';
- * import type {FullPrismaModel} from '@augment-vir/common';
- *
- * function doThing(fullModel: FullModel<Prisma.TypeMap, 'User'>) {}
- * ```
- *
- * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
- */
-export type FullPrismaModel<PrismaTypeMap extends BasePrismaTypeMap, Model extends ModelNameFromPrismaTypeMap<PrismaTypeMap>> = ExpandPrismaTypeMapPayload<PrismaTypeMap['model'][Model]['payload']>;
-/**
- * A base model entry with only its immediate properties from the given Prisma type map and model
- * name.
- *
- * @category Prisma : Common
- * @category Package : @augment-vir/common
- * @example
- *
- * ```ts
- * import type {Prisma} from '@prisma/client';
- * import type {BasePrismaModel} from '@augment-vir/common';
- *
- * function doThing(fullModel: BaseModel<Prisma.TypeMap, 'User'>) {}
- * ```
- *
- * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
- */
-export type BasePrismaModel<PrismaTypeMap extends BasePrismaTypeMap, Model extends ModelNameFromPrismaTypeMap<PrismaTypeMap>> = PrismaTypeMap['model'][Model]['payload']['scalars'];
-/**
- * Expand a Prisma payload into its scalars and recursive relations.
- *
- * @category Prisma : Common : Util
- * @category Package : @augment-vir/common
- * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
- */
-export type ExpandPrismaTypeMapPayload<Payload extends BasePrismaPayload> = Payload['scalars'] & {
-    [Key in keyof Payload['objects']]: ExpandPotentialArrayPrismaTypeMapPayload<NonNullable<Payload['objects'][Key]>> | (null extends Payload['objects'][Key] ? null : never);
-};
-/**
- * Expand a payload that might be inside of an array, keeping it inside of an array if it is.
- *
- * @category Prisma : Common : Util
- * @category Package : @augment-vir/common
- * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
- */
-export type ExpandPotentialArrayPrismaTypeMapPayload<PayloadWrapper extends BasePrismaPayload | BasePrismaPayload[]> = PayloadWrapper extends (infer ActualPayload extends BasePrismaPayload)[] ? ExpandPrismaTypeMapPayload<ActualPayload>[] : PayloadWrapper extends BasePrismaPayload ? ExpandPrismaTypeMapPayload<PayloadWrapper> : never;