✨ support scalar lists

maticzav · maticzav · commit 30285899cc0e · 2020-03-10T12:40:38.000+01:00
diff --git a/README.md b/README.md
@@ -27,7 +27,7 @@ No installation! Comes preinstalled with `prisma2`! 🎉
 ```prisma
 generator test-utils {
   provider = "prisma-test-utils"
-  output = "node*modules/@generated/test-utils"
+  output = "node-modules/@generated/test-utils"
 }
 ```
 
@@ -141,7 +141,7 @@ test('test with seed data', async () => {
   await seed({
     client,
     models: kit => ({
-      _: {
+      '*': {
         /* Default number of instances. */
         amount: 500,
       },
@@ -155,6 +155,8 @@ test('test with seed data', async () => {
           entry: () => {
             return `A generated entry from the function.`
           },
+          /* Define scalar list mock functions */
+          tags: () => kit.faker.n(kit.faker.name, 3)
           /* Manage relations. */
           posts: {
             max: 100,
diff --git a/src/__test.ts b/src/__test.ts
@@ -7,7 +7,24 @@
 
 //   const seed: SeedFunction<PrismaClient, GeneratedSeedModels> = getSeed(dmmf)
 
-//   // debugger
+//   const dogo = await client.pet.create({
+//     data: {
+//       name: 'wubju',
+//       nicknames: {
+//         set: [
+//           'Arthur Parker',
+//           'Jack Chavez',
+//           'Hunter Franklin',
+//           'Betty Gill',
+//           'Louis Reeves',
+//         ],
+//       },
+//       animal: 'Dog',
+//       birthday: '2040-07-14T19:13:01.534Z',
+//     },
+//   })
+
+//   debugger
 
 //   // const user = await client.user.create({
 //   //   data: {
@@ -34,6 +51,12 @@
 //       '*': {
 //         amount: 3,
 //       },
+//       Pet: {
+//         factory: {
+//           animal: 'Dog',
+//           nicknames: () => kit.faker.n(kit.faker.name, 5),
+//         },
+//       },
 //     }),
 //   })
 
diff --git a/src/intellisense/seed.ts b/src/intellisense/seed.ts
@@ -97,12 +97,16 @@ export function generateGeneratedSeedModelsType(dmmf: DMMF.Document): string {
         }
       }
       case 'scalar': {
+        const scalar = getTSTypeFromDMMFScalar(field.type)
+        const supported = isSupportedScalar(field)
+        if (field.isList) {
+          /* prettier-ignore */
+          return `${field.name}${q(supported)}: ${scalar}[] | (() => ${scalar}[])`
+        }
         /**
          * The field should provide a function which results in a type
          * of the scalar.
          */
-        const scalar = getTSTypeFromDMMFScalar(field.type)
-        const supported = isSupportedScalar(field)
         return `${field.name}${q(supported)}: ${scalar} | (() => ${scalar})`
       }
       default: {
diff --git a/src/static/seed.ts b/src/static/seed.ts
@@ -1,7 +1,6 @@
-import { DMMF, debug } from '@prisma/client/runtime'
+import { DMMF } from '@prisma/client/runtime'
 import Chance from 'chance'
-import _ from 'lodash'
-import { Dictionary } from 'lodash'
+import _, { Dictionary } from 'lodash'
 import mls from 'multilines'
 
 import { Scalar } from './scalars'
@@ -13,6 +12,7 @@ import {
   SeedModelFieldRelationConstraint,
   SeedFunction,
   PrismaClientType,
+  SeedModelScalarListDefinition,
 } from './types'
 import { withDefault, not, filterKeys, mapEntries } from './utils'
 
@@ -136,12 +136,11 @@ export function getSeed<
    *  - { ArtistId: "uniqueid" }
    */
   type ID = Dictionary<string | number>
+  type Scalar = string | number | boolean | Date
 
   type FixtureData = Dictionary<
-    | string
-    | number
-    | boolean
-    | Date
+    | Scalar
+    | { set: Scalar[] }
     | { connect: ID }
     | { connect: ID[] }
     | { create: FixtureData }
@@ -581,7 +580,10 @@ export function getSeed<
          *
          * -> We should create B and connect As to it.
          */
-        return { optional: false, from: relationModel }
+        return {
+          optional: false,
+          from: relationModel,
+        }
       } else if (field.isList && backRelationField.isRequired) {
         /**
          * model A {
@@ -593,7 +595,10 @@ export function getSeed<
          *
          * -> We should create A and connect Bs to it later.
          */
-        return { optional: false, from: fieldModel }
+        return {
+          optional: false,
+          from: fieldModel,
+        }
       } else if (field.isList && !backRelationField.isRequired) {
         /**
          * model A {
@@ -763,7 +768,10 @@ export function getSeed<
       ordinal: number,
       pool: Pool,
       order: Order,
-    ): { step: Step; pool: Pool } {
+    ): {
+      step: Step
+      pool: Pool
+    } {
       /**
        * Fix optional relations' direction.
        */
@@ -806,7 +814,10 @@ export function getSeed<
         [order.model.name]: order.model,
       }
 
-      return { step, pool: newPool }
+      return {
+        step,
+        pool: newPool,
+      }
     }
   }
 
@@ -956,7 +967,9 @@ export function getSeed<
       pool: Pool
       tasks: Task[]
       data: FixtureData
-      include: { [field: string]: true | { include: Mock['include'] } }
+      include: {
+        [field: string]: true | { include: Mock['include'] }
+      }
     }
 
     /**
@@ -998,20 +1011,52 @@ export function getSeed<
           switch (typeof mock) {
             case 'function': {
               /* Custom function */
-              const value = mock.call(faker)
-              return {
-                pool,
-                tasks,
-                data: {
-                  ...data,
-                  [field.name]: value,
-                },
-                include,
+              if (field.isList) {
+                const values = (mock as () => SeedModelFieldDefinition[]).call(
+                  faker,
+                )
+                return {
+                  pool,
+                  tasks,
+                  data: {
+                    ...data,
+                    [field.name]: { set: values },
+                  },
+                  include,
+                }
+              } else {
+                const value = (mock as () => SeedModelFieldDefinition).call(
+                  faker,
+                )
+                return {
+                  pool,
+                  tasks,
+                  data: {
+                    ...data,
+                    [field.name]: value,
+                  },
+                  include,
+                }
               }
             }
             case 'object': {
-              /* Relation constraint */
-              break
+              /* Relation or scalar list */
+              if (field.isList) {
+                /* Scalar list */
+                const values = mock as SeedModelFieldDefinition[]
+                return {
+                  pool,
+                  tasks,
+                  data: {
+                    ...data,
+                    [field.name]: { set: values },
+                  },
+                  include,
+                }
+              } else {
+                /* Relation */
+                break
+              }
             }
             case 'bigint':
             case 'boolean':
@@ -1078,6 +1123,104 @@ export function getSeed<
 
         switch (field.kind) {
           case 'scalar': {
+            /**
+             * List scalar mocks.
+             *
+             * We provide good default mocks for functions. Anything more complex
+             * or flexible can be achieved using the exposed Chance.js library.
+             */
+            if (field.isList) {
+              switch (field.type) {
+                /**
+                 * Scalars
+                 */
+                case Scalar.string: {
+                  const strings = faker.n(faker.string, 3)
+
+                  return {
+                    pool,
+                    tasks,
+                    data: {
+                      ...data,
+                      [field.name]: {
+                        set: strings,
+                      },
+                    },
+                    include,
+                  }
+                }
+                case Scalar.int: {
+                  const numbers = faker.n(faker.integer, 3, {
+                    min: -2000,
+                    max: 2000,
+                  })
+
+                  return {
+                    pool,
+                    tasks,
+                    data: {
+                      ...data,
+                      [field.name]: { set: numbers },
+                    },
+                    include,
+                  }
+                }
+                case Scalar.float: {
+                  const floats = faker.n(faker.floating, 3, {
+                    min: -1000,
+                    max: 1000,
+                    fixed: 2,
+                  })
+
+                  return {
+                    pool,
+                    tasks,
+                    data: {
+                      ...data,
+                      [field.name]: { set: floats },
+                    },
+                    include,
+                  }
+                }
+                case Scalar.date: {
+                  const dates = faker.n(faker.date, 3)
+
+                  return {
+                    pool,
+                    tasks,
+                    data: {
+                      ...data,
+                      [field.name]: { set: dates },
+                    },
+                    include,
+                  }
+                }
+                case Scalar.bool: {
+                  const booleans = faker.n(faker.bool, 3)
+
+                  return {
+                    pool,
+                    tasks,
+                    data: {
+                      ...data,
+                      [field.name]: { set: booleans },
+                    },
+                    include,
+                  }
+                }
+                /* Unsupported scalar */
+                default: {
+                  throw new Error(
+                    `Unsupported scalar field ${task.model.name}${field.name} of type ${field.type}`,
+                  )
+                }
+              }
+            }
+
+            /**
+             * Scalar mocks.
+             */
+
             switch (field.type) {
               /**
                * Scalars
@@ -1154,7 +1297,7 @@ export function getSeed<
               /* Unsupported scalar */
               default: {
                 throw new Error(
-                  `Unsupported scalar field of type ${field.type}`,
+                  `Unsupported scalar field ${task.model.name}${field.name} of type ${field.type}`,
                 )
               }
             }
diff --git a/src/static/types.ts b/src/static/types.ts
@@ -28,12 +28,15 @@ export type SeedModel = {
   factory?: Dictionary<
     | SeedModelFieldDefinition
     | (() => SeedModelFieldDefinition)
+    | SeedModelScalarListDefinition
     | SeedModelFieldRelationConstraint
   >
 }
 
-export type SeedModelFieldDefinition = string | number | boolean // ID |
-
+export type SeedModelFieldDefinition = string | number | boolean
+export type SeedModelScalarListDefinition =
+  | SeedModelFieldDefinition[]
+  | (() => SeedModelFieldDefinition[])
 export type SeedModelFieldRelationConstraint = {
   min?: number
   max?: number
diff --git a/tests/seed/schema.prisma b/tests/seed/schema.prisma

Original file line number	Diff line number	Diff line change
`@@ -97,12 +97,16 @@ export function generateGeneratedSeedModelsType(dmmf: DMMF.Document): string {`
`97`	`97`	`}`
`98`	`98`	`}`
`99`	`99`	`case 'scalar': {`
	`100`	`+ const scalar = getTSTypeFromDMMFScalar(field.type)`
	`101`	`+ const supported = isSupportedScalar(field)`
	`102`	`+ if (field.isList) {`
	`103`	`+ /* prettier-ignore */`
	`104`	+ return `${field.name}${q(supported)}: ${scalar}[] \| (() => ${scalar}[])`
	`105`	`+ }`
`100`	`106`	`/**`
`101`	`107`	`* The field should provide a function which results in a type`
`102`	`108`	`* of the scalar.`
`103`	`109`	`*/`
`104`		`- const scalar = getTSTypeFromDMMFScalar(field.type)`
`105`		`- const supported = isSupportedScalar(field)`
`106`	`110`	return `${field.name}${q(supported)}: ${scalar} \| (() => ${scalar})`
`107`	`111`	`}`
`108`	`112`	`default: {`