From 3cfc51ecf424d42e95920a4e7e1d05649d833330 Mon Sep 17 00:00:00 2001 From: James Date: Tue, 19 Sep 2023 15:26:08 -0400 Subject: [PATCH] chore: hasMany numbers --- .../db-postgres/src/find/buildFindManyArgs.ts | 10 +++ packages/db-postgres/src/schema/build.ts | 59 ++++++++++++++++- .../db-postgres/src/schema/traverseFields.ts | 51 +++++++++++++-- .../src/transform/read/hasManyNumber.ts | 19 ++++++ .../db-postgres/src/transform/read/index.ts | 11 +++- .../src/transform/read/traverseFields.ts | 50 +++++++++++++- .../db-postgres/src/transform/write/index.ts | 2 + .../src/transform/write/numbers.ts | 15 +++++ .../src/transform/write/traverseFields.ts | 38 +++++++++++ .../db-postgres/src/transform/write/types.ts | 1 + packages/db-postgres/src/upsertRow/index.ts | 65 ++++++++++++++----- .../src/utilities/createPathMap.ts | 22 +++++++ .../src/utilities/createRelationshipMap.ts | 24 ------- test/_community/config.ts | 30 +++++---- 14 files changed, 333 insertions(+), 64 deletions(-) create mode 100644 packages/db-postgres/src/transform/read/hasManyNumber.ts create mode 100644 packages/db-postgres/src/transform/write/numbers.ts create mode 100644 packages/db-postgres/src/utilities/createPathMap.ts delete mode 100644 packages/db-postgres/src/utilities/createRelationshipMap.ts diff --git a/packages/db-postgres/src/find/buildFindManyArgs.ts b/packages/db-postgres/src/find/buildFindManyArgs.ts index aa34390e64..f04a849019 100644 --- a/packages/db-postgres/src/find/buildFindManyArgs.ts +++ b/packages/db-postgres/src/find/buildFindManyArgs.ts @@ -33,6 +33,16 @@ export const buildFindManyArgs = ({ }, } + if (adapter.tables[`${tableName}_numbers`]) { + result.with._numbers = { + columns: { + id: false, + parent: false, + }, + orderBy: ({ order }, { asc: ASC }) => [ASC(order)], + } + } + if (adapter.tables[`${tableName}_relationships`]) { result.with._relationships = { columns: { diff --git a/packages/db-postgres/src/schema/build.ts b/packages/db-postgres/src/schema/build.ts index 9cb23f2abf..e812131b80 100644 --- a/packages/db-postgres/src/schema/build.ts +++ b/packages/db-postgres/src/schema/build.ts @@ -50,9 +50,13 @@ export const buildTable = ({ let hasLocalizedField = false let hasLocalizedRelationshipField = false + let hasManyNumberField: 'index' | boolean = false + let hasLocalizedManyNumberField = false + const localesColumns: Record = {} const localesIndexes: Record IndexBuilder> = {} let localesTable: GenericTable + let numbersTable: GenericTable const relationships: Set = new Set() let relationshipsTable: GenericTable @@ -76,7 +80,12 @@ export const buildTable = ({ columns.id = serial('id').primaryKey() } - ;({ hasLocalizedField, hasLocalizedRelationshipField } = traverseFields({ + ;({ + hasLocalizedField, + hasLocalizedManyNumberField, + hasLocalizedRelationshipField, + hasManyNumberField, + } = traverseFields({ adapter, arrayBlockRelations, buildRelationships, @@ -141,6 +150,50 @@ export const buildTable = ({ adapter.relations[`relations_${localeTableName}`] = localesTableRelations } + if (hasManyNumberField) { + const numbersTableName = `${tableName}_numbers` + const columns: Record = { + id: serial('id').primaryKey(), + number: numeric('number'), + order: integer('order').notNull(), + parent: parentIDColumnMap[idColType]('parent_id') + .references(() => table.id, { onDelete: 'cascade' }) + .notNull(), + path: varchar('path').notNull(), + } + + if (hasLocalizedManyNumberField) { + columns.locale = adapter.enums._locales('locale') + } + + numbersTable = pgTable(numbersTableName, columns, (cols) => { + const indexes: Record = { + orderParentIdx: index('order_parent_idx').on(cols.order, cols.parent), + } + + if (hasManyNumberField === 'index') { + indexes.numberIdx = index('number_idx').on(cols.number) + } + + if (hasLocalizedManyNumberField) { + indexes.localeParent = index('locale_parent').on(cols.locale, cols.parent) + } + + return indexes + }) + + adapter.tables[numbersTableName] = numbersTable + + const numbersTableRelations = relations(numbersTable, ({ one }) => ({ + parent: one(table, { + fields: [numbersTable.parent], + references: [table.id], + }), + })) + + adapter.relations[`relations_${numbersTableName}`] = numbersTableRelations + } + if (buildRelationships) { if (relationships.size) { const relationshipColumns: Record = { @@ -228,6 +281,10 @@ export const buildTable = ({ result._locales = many(localesTable) } + if (hasManyNumberField) { + result._numbers = many(numbersTable) + } + if (relationships.size && relationshipsTable) { result._relationships = many(relationshipsTable, { relationName: '_relationships', diff --git a/packages/db-postgres/src/schema/traverseFields.ts b/packages/db-postgres/src/schema/traverseFields.ts index 4fdb2cc81d..cf29e43d65 100644 --- a/packages/db-postgres/src/schema/traverseFields.ts +++ b/packages/db-postgres/src/schema/traverseFields.ts @@ -14,6 +14,7 @@ import { unique, varchar, } from 'drizzle-orm/pg-core' +import { InvalidConfiguration } from 'payload/errors' import { fieldAffectsData } from 'payload/types' import toSnakeCase from 'to-snake-case' @@ -43,7 +44,9 @@ type Args = { type Result = { hasLocalizedField: boolean + hasLocalizedManyNumberField: boolean hasLocalizedRelationshipField: boolean + hasManyNumberField: 'index' | boolean } export const traverseFields = ({ @@ -64,6 +67,8 @@ export const traverseFields = ({ }: Args): Result => { let hasLocalizedField = false let hasLocalizedRelationshipField = false + let hasManyNumberField: 'index' | boolean = false + let hasLocalizedManyNumberField = false let parentIDColType = 'integer' if (columns.id instanceof PgNumericBuilder) parentIDColType = 'numeric' @@ -104,16 +109,30 @@ export const traverseFields = ({ case 'email': case 'code': case 'textarea': { - // TODO: handle hasMany - // TODO: handle min / max length targetTable[`${fieldPrefix || ''}${field.name}`] = varchar(columnName) break } case 'number': { - // TODO: handle hasMany - // TODO: handle min / max - targetTable[`${fieldPrefix || ''}${field.name}`] = numeric(columnName) + if (field.hasMany) { + if (field.localized) { + hasLocalizedManyNumberField = true + } + + if (field.index) { + hasManyNumberField = 'index' + } else if (!hasManyNumberField) { + hasManyNumberField = true + } + + if (field.unique) { + throw new InvalidConfiguration( + 'Unique is not supported in Postgres for hasMany number fields.', + ) + } + } else { + targetTable[`${fieldPrefix || ''}${field.name}`] = numeric(columnName) + } break } @@ -268,7 +287,9 @@ export const traverseFields = ({ case 'group': { const { hasLocalizedField: groupHasLocalizedField, + hasLocalizedManyNumberField: groupHasLocalizedManyNumberField, hasLocalizedRelationshipField: groupHasLocalizedRelationshipField, + hasManyNumberField: groupHasManyNumberField, } = traverseFields({ adapter, arrayBlockRelations, @@ -288,6 +309,8 @@ export const traverseFields = ({ if (groupHasLocalizedField) hasLocalizedField = true if (groupHasLocalizedRelationshipField) hasLocalizedRelationshipField = true + if (groupHasManyNumberField) hasManyNumberField = true + if (groupHasLocalizedManyNumberField) hasLocalizedManyNumberField = true break } @@ -296,7 +319,9 @@ export const traverseFields = ({ if ('name' in tab) { const { hasLocalizedField: tabHasLocalizedField, + hasLocalizedManyNumberField: tabHasLocalizedManyNumberField, hasLocalizedRelationshipField: tabHasLocalizedRelationshipField, + hasManyNumberField: tabHasManyNumberField, } = traverseFields({ adapter, arrayBlockRelations, @@ -315,6 +340,8 @@ export const traverseFields = ({ if (tabHasLocalizedField) hasLocalizedField = true if (tabHasLocalizedRelationshipField) hasLocalizedRelationshipField = true + if (tabHasManyNumberField) hasManyNumberField = true + if (tabHasLocalizedManyNumberField) hasLocalizedManyNumberField = true } else { ;({ hasLocalizedField, hasLocalizedRelationshipField } = traverseFields({ adapter, @@ -338,7 +365,12 @@ export const traverseFields = ({ case 'row': case 'collapsible': { - ;({ hasLocalizedField, hasLocalizedRelationshipField } = traverseFields({ + ;({ + hasLocalizedField, + hasLocalizedManyNumberField, + hasLocalizedRelationshipField, + hasManyNumberField, + } = traverseFields({ adapter, arrayBlockRelations, buildRelationships, @@ -374,5 +406,10 @@ export const traverseFields = ({ } }) - return { hasLocalizedField, hasLocalizedRelationshipField } + return { + hasLocalizedField, + hasLocalizedManyNumberField, + hasLocalizedRelationshipField, + hasManyNumberField, + } } diff --git a/packages/db-postgres/src/transform/read/hasManyNumber.ts b/packages/db-postgres/src/transform/read/hasManyNumber.ts new file mode 100644 index 0000000000..ad673bb1e6 --- /dev/null +++ b/packages/db-postgres/src/transform/read/hasManyNumber.ts @@ -0,0 +1,19 @@ +/* eslint-disable no-param-reassign */ +import type { NumberField } from 'payload/types' + +type Args = { + field: NumberField + locale?: string + numberRows: Record[] + ref: Record +} + +export const transformHasManyNumber = ({ field, locale, numberRows, ref }: Args) => { + const result = numberRows.map(({ number }) => number) + + if (locale) { + ref[field.name][locale] = result + } else { + ref[field.name] = result + } +} diff --git a/packages/db-postgres/src/transform/read/index.ts b/packages/db-postgres/src/transform/read/index.ts index a07b7c7a75..c8e1c5a2bf 100644 --- a/packages/db-postgres/src/transform/read/index.ts +++ b/packages/db-postgres/src/transform/read/index.ts @@ -3,7 +3,7 @@ import type { SanitizedConfig } from 'payload/config' import type { Field, TypeWithID } from 'payload/types' import { createBlocksMap } from '../../utilities/createBlocksMap' -import { createRelationshipMap } from '../../utilities/createRelationshipMap' +import { createPathMap } from '../../utilities/createPathMap' import { traverseFields } from './traverseFields' type TransformArgs = { @@ -18,12 +18,18 @@ type TransformArgs = { // into the shape Payload expects based on field schema export const transform = ({ config, data, fields }: TransformArgs): T => { let relationships: Record[]> = {} + let numbers: Record[]> = {} if ('_relationships' in data) { - relationships = createRelationshipMap(data._relationships) + relationships = createPathMap(data._relationships) delete data._relationships } + if ('_numbers' in data) { + numbers = createPathMap(data._numbers) + delete data._numbers + } + const blocks = createBlocksMap(data) const result = traverseFields({ @@ -34,6 +40,7 @@ export const transform = ({ config, data, fields }: Transf }, fieldPrefix: '', fields, + numbers, path: '', relationships, table: data, diff --git a/packages/db-postgres/src/transform/read/traverseFields.ts b/packages/db-postgres/src/transform/read/traverseFields.ts index 98de064b60..10d625171e 100644 --- a/packages/db-postgres/src/transform/read/traverseFields.ts +++ b/packages/db-postgres/src/transform/read/traverseFields.ts @@ -2,10 +2,11 @@ import type { SanitizedConfig } from 'payload/config' import type { Field, TabAsField } from 'payload/types' -import { fieldAffectsData, tabHasName } from 'payload/types' +import { fieldAffectsData } from 'payload/types' import type { BlocksMap } from '../../utilities/createBlocksMap' +import { transformHasManyNumber } from './hasManyNumber' import { transformRelationship } from './relationship' type TraverseFieldsArgs = { @@ -29,6 +30,10 @@ type TraverseFieldsArgs = { * An array of Payload fields to traverse */ fields: (Field | TabAsField)[] + /** + * All hasMany number fields, as returned by Drizzle, keyed on an object by field path + */ + numbers: Record[]> /** * The current field path (in dot notation), used to merge in relationships */ @@ -51,6 +56,7 @@ export const traverseFields = >({ dataRef, fieldPrefix, fields, + numbers, path, relationships, table, @@ -65,6 +71,7 @@ export const traverseFields = >({ dataRef, fieldPrefix, fields: field.tabs.map((tab) => ({ ...tab, type: 'tab' })), + numbers, path, relationships, table, @@ -82,6 +89,7 @@ export const traverseFields = >({ dataRef, fieldPrefix, fields: field.fields, + numbers, path, relationships, table, @@ -104,6 +112,7 @@ export const traverseFields = >({ dataRef: row, fieldPrefix: '', fields: field.fields, + numbers, path: `${sanitizedPath}${field.name}.${row._order - 1}`, relationships, table: row, @@ -123,6 +132,7 @@ export const traverseFields = >({ dataRef: row, fieldPrefix: '', fields: field.fields, + numbers, path: `${sanitizedPath}${field.name}.${i}`, relationships, table: row, @@ -160,6 +170,7 @@ export const traverseFields = >({ dataRef: row, fieldPrefix: '', fields: block.fields, + numbers, path: `${blockFieldPath}.${row._order - 1}`, relationships, table: row, @@ -184,6 +195,7 @@ export const traverseFields = >({ dataRef: row, fieldPrefix: '', fields: block.fields, + numbers, path: `${blockFieldPath}.${i}`, relationships, table: row, @@ -232,6 +244,40 @@ export const traverseFields = >({ return result } + if (field.type === 'number' && field.hasMany) { + const numberPathMatch = numbers[`${sanitizedPath}${field.name}`] + if (!numberPathMatch) return result + + if (field.localized) { + result[field.name] = {} + const numbersByLocale: Record[]> = {} + + numberPathMatch.forEach((row) => { + if (typeof row.locale === 'string') { + if (!numbersByLocale[row.locale]) numbersByLocale[row.locale] = [] + numbersByLocale[row.locale].push(row) + } + }) + + Object.entries(numbersByLocale).forEach(([locale, numbers]) => { + transformHasManyNumber({ + field, + locale, + numberRows: numbers, + ref: result, + }) + }) + } else { + transformHasManyNumber({ + field, + numberRows: numberPathMatch, + ref: result, + }) + } + + return result + } + const localizedFieldData = {} const valuesToTransform: { ref: Record @@ -266,6 +312,7 @@ export const traverseFields = >({ dataRef: groupLocaleData as Record, fieldPrefix: groupFieldPrefix, fields: field.fields, + numbers, path: `${sanitizedPath}${field.name}`, relationships, table, @@ -278,6 +325,7 @@ export const traverseFields = >({ dataRef: groupData as Record, fieldPrefix: groupFieldPrefix, fields: field.fields, + numbers, path: `${sanitizedPath}${field.name}`, relationships, table, diff --git a/packages/db-postgres/src/transform/write/index.ts b/packages/db-postgres/src/transform/write/index.ts index 5783f889e8..6d1f672b31 100644 --- a/packages/db-postgres/src/transform/write/index.ts +++ b/packages/db-postgres/src/transform/write/index.ts @@ -19,6 +19,7 @@ export const transformForWrite = ({ data, fields, path = '', tableName }: Args): arrays: {}, blocks: {}, locales: {}, + numbers: [], relationships: [], row: {}, } @@ -33,6 +34,7 @@ export const transformForWrite = ({ data, fields, path = '', tableName }: Args): fields, locales: rowToInsert.locales, newTableName: tableName, + numbers: rowToInsert.numbers, parentTableName: tableName, path, relationships: rowToInsert.relationships, diff --git a/packages/db-postgres/src/transform/write/numbers.ts b/packages/db-postgres/src/transform/write/numbers.ts new file mode 100644 index 0000000000..66e03b8050 --- /dev/null +++ b/packages/db-postgres/src/transform/write/numbers.ts @@ -0,0 +1,15 @@ +type Args = { + baseRow: Record + data: unknown[] + numbers: Record[] +} + +export const transformNumbers = ({ baseRow, data, numbers }: Args) => { + data.forEach((val, i) => { + numbers.push({ + ...baseRow, + number: val, + order: i + 1, + }) + }) +} diff --git a/packages/db-postgres/src/transform/write/traverseFields.ts b/packages/db-postgres/src/transform/write/traverseFields.ts index 1a26143017..2002c12b7f 100644 --- a/packages/db-postgres/src/transform/write/traverseFields.ts +++ b/packages/db-postgres/src/transform/write/traverseFields.ts @@ -9,6 +9,7 @@ import type { ArrayRowToInsert, BlockRowToInsert } from './types' import { isArrayOfRows } from '../../utilities/isArrayOfRows' import { transformArray } from './array' import { transformBlocks } from './blocks' +import { transformNumbers } from './numbers' import { transformRelationship } from './relationships' type Args = { @@ -27,6 +28,7 @@ type Args = { [locale: string]: Record } newTableName: string + numbers: Record[] parentTableName: string path: string relationships: Record[] @@ -43,6 +45,7 @@ export const traverseFields = ({ forcedLocale, locales, newTableName, + numbers, parentTableName, path, relationships, @@ -142,6 +145,7 @@ export const traverseFields = ({ forcedLocale: localeKey, locales, newTableName: parentTableName, + numbers, parentTableName, path: `${path || ''}${field.name}.`, relationships, @@ -158,6 +162,7 @@ export const traverseFields = ({ fields: field.fields, locales, newTableName: parentTableName, + numbers, parentTableName, path: `${path || ''}${field.name}.`, relationships, @@ -185,6 +190,7 @@ export const traverseFields = ({ forcedLocale: localeKey, locales, newTableName: parentTableName, + numbers, parentTableName, path: `${path || ''}${tab.name}.`, relationships, @@ -201,6 +207,7 @@ export const traverseFields = ({ fields: tab.fields, locales, newTableName: parentTableName, + numbers, parentTableName, path: `${path || ''}${tab.name}.`, relationships, @@ -218,6 +225,7 @@ export const traverseFields = ({ fields: tab.fields, locales, newTableName: parentTableName, + numbers, parentTableName, path, relationships, @@ -237,6 +245,7 @@ export const traverseFields = ({ fields: field.fields, locales, newTableName: parentTableName, + numbers, parentTableName, path, relationships, @@ -275,6 +284,35 @@ export const traverseFields = ({ return } + if (field.type === 'number' && field.hasMany && Array.isArray(fieldData)) { + const numberPath = `${path || ''}${field.name}` + + if (field.localized) { + if (typeof fieldData === 'object') { + Object.entries(fieldData).forEach(([localeKey, localeData]) => { + transformNumbers({ + baseRow: { + locale: localeKey, + path: numberPath, + }, + data: localeData, + numbers, + }) + }) + } + } else { + transformNumbers({ + baseRow: { + path: numberPath, + }, + data: fieldData, + numbers, + }) + } + + return + } + if (fieldAffectsData(field)) { const valuesToTransform: { localeKey?: string; ref: unknown; value: unknown }[] = [] diff --git a/packages/db-postgres/src/transform/write/types.ts b/packages/db-postgres/src/transform/write/types.ts index 332eb57ba8..6830f94214 100644 --- a/packages/db-postgres/src/transform/write/types.ts +++ b/packages/db-postgres/src/transform/write/types.ts @@ -29,6 +29,7 @@ export type RowToInsert = { locales: { [locale: string]: Record } + numbers: Record[] relationships: Record[] row: Record } diff --git a/packages/db-postgres/src/upsertRow/index.ts b/packages/db-postgres/src/upsertRow/index.ts index 76904025a8..1816fa7fa3 100644 --- a/packages/db-postgres/src/upsertRow/index.ts +++ b/packages/db-postgres/src/upsertRow/index.ts @@ -58,6 +58,7 @@ export const upsertRow = async ({ const localesToInsert: Record[] = [] const relationsToInsert: Record[] = [] + const numbersToInsert: Record[] = [] const blocksToInsert: { [blockType: string]: BlockRowToInsert[] } = {} // Maintain a list of promises to run locale, blocks, and relationships @@ -81,6 +82,14 @@ export const upsertRow = async ({ }) } + // If there are numbers, add parent to each + if (rowToInsert.numbers.length > 0) { + rowToInsert.numbers.forEach((numberRow) => { + numberRow.parent = insertedRow.id + numbersToInsert.push(numberRow) + }) + } + // If there are blocks, add parent to each, and then // store by table name and rows Object.keys(rowToInsert.blocks).forEach((blockName) => { @@ -111,24 +120,48 @@ export const upsertRow = async ({ // INSERT RELATIONSHIPS // ////////////////////////////////// - if (relationsToInsert.length > 0) { - promises.push(async () => { - const relationshipsTableName = `${tableName}_relationships` - if (operation === 'update') { - await deleteExistingRowsByPath({ - adapter, - localeColumnName: 'locale', - newRows: relationsToInsert, - parentColumnName: 'parent', - parentID: insertedRow.id, - pathColumnName: 'path', - tableName: relationshipsTableName, - }) - } + promises.push(async () => { + const relationshipsTableName = `${tableName}_relationships` + if (operation === 'update') { + await deleteExistingRowsByPath({ + adapter, + localeColumnName: 'locale', + newRows: relationsToInsert, + parentColumnName: 'parent', + parentID: insertedRow.id, + pathColumnName: 'path', + tableName: relationshipsTableName, + }) + } + if (relationsToInsert.length > 0) { await db.insert(adapter.tables[relationshipsTableName]).values(relationsToInsert).returning() - }) - } + } + }) + + // ////////////////////////////////// + // INSERT hasMany NUMBERS + // ////////////////////////////////// + + promises.push(async () => { + const numbersTableName = `${tableName}_numbers` + + if (operation === 'update') { + await deleteExistingRowsByPath({ + adapter, + localeColumnName: 'locale', + newRows: numbersToInsert, + parentColumnName: 'parent', + parentID: insertedRow.id, + pathColumnName: 'path', + tableName: numbersTableName, + }) + } + + if (numbersToInsert.length > 0) { + await db.insert(adapter.tables[numbersTableName]).values(numbersToInsert).returning() + } + }) // ////////////////////////////////// // INSERT BLOCKS diff --git a/packages/db-postgres/src/utilities/createPathMap.ts b/packages/db-postgres/src/utilities/createPathMap.ts new file mode 100644 index 0000000000..c05c356ebd --- /dev/null +++ b/packages/db-postgres/src/utilities/createPathMap.ts @@ -0,0 +1,22 @@ +// Flatten rows to object with path keys +// for easier retrieval +export const createPathMap = (rows: unknown): Record[]> => { + let rowsByPath = {} + + if (Array.isArray(rows)) { + rowsByPath = rows.reduce((res, row) => { + const formattedRow = { + ...row, + } + + delete formattedRow.path + + if (!res[row.path]) res[row.path] = [] + res[row.path].push(row) + + return res + }, {}) + } + + return rowsByPath +} diff --git a/packages/db-postgres/src/utilities/createRelationshipMap.ts b/packages/db-postgres/src/utilities/createRelationshipMap.ts deleted file mode 100644 index 2ea7b27662..0000000000 --- a/packages/db-postgres/src/utilities/createRelationshipMap.ts +++ /dev/null @@ -1,24 +0,0 @@ -// Flatten relationships to object with path keys -// for easier retrieval -export const createRelationshipMap = ( - rawRelationships: unknown, -): Record[]> => { - let relationships = {} - - if (Array.isArray(rawRelationships)) { - relationships = rawRelationships.reduce((res, relation) => { - const formattedRelation = { - ...relation, - } - - delete formattedRelation.path - - if (!res[relation.path]) res[relation.path] = [] - res[relation.path].push(formattedRelation) - - return res - }, {}) - } - - return relationships -} diff --git a/test/_community/config.ts b/test/_community/config.ts index f3b424c3e9..1602396b4b 100644 --- a/test/_community/config.ts +++ b/test/_community/config.ts @@ -7,12 +7,22 @@ import { MenuGlobal } from './globals/Menu' export default buildConfigWithDefaults({ // ...extend config here collections: [ - PostsCollection, - MediaCollection, + // PostsCollection, + { + slug: 'posts', + fields: [ + { + name: 'myNumberField', + type: 'number', + hasMany: true, + }, + ], + }, + // MediaCollection, // ...add more collections here ], globals: [ - MenuGlobal, + // MenuGlobal, // ...add more globals here ], graphQL: { @@ -20,19 +30,13 @@ export default buildConfigWithDefaults({ }, onInit: async (payload) => { - await payload.create({ - collection: 'users', + const numberField = await payload.create({ + collection: 'posts', data: { - email: devUser.email, - password: devUser.password, + myNumberField: [12, 543, 54], }, }) - await payload.create({ - collection: postsSlug, - data: { - text: 'example post', - }, - }) + console.log(numberField) }, })