Method processCreate

packages/server/src/api/rest/index.ts:1470–1531

(
        client: ClientContract<Schema>,
        type: string,
        _query: Record<string, string | string[]> | undefined,
        requestBody: unknown,
    )

    }

    private async processCreate(
        client: ClientContract<Schema>,
        type: string,
        _query: Record<string, string | string[]> | undefined,
        requestBody: unknown,
    ): Promise<Response> {
        const typeInfo = this.getModelInfo(type);
        if (!typeInfo) {
            return this.makeUnsupportedModelError(type);
        }

        const { attributes, relationships, error } = this.processRequestBody(requestBody);
        if (error) {
            return error;
        }

        const createPayload: any = { data: { ...attributes } };

        // turn relationship payload into `connect` objects
        if (relationships) {
            for (const [key, data] of Object.entries<any>(relationships)) {
                if (!data?.data) {
                    return this.makeError('invalidRelationData');
                }

                const relationInfo = typeInfo.relationships[key];
                if (!relationInfo) {
                    return this.makeUnsupportedRelationshipError(type, key, 400);
                }

                if (relationInfo.isCollection) {
                    createPayload.data[key] = {
                        connect: enumerate(data.data).map((item: any) =>
                            this.makeIdConnect(relationInfo.idFields, item.id),
                        ),
                    };
                } else {
                    if (typeof data.data !== 'object') {
                        return this.makeError('invalidRelationData');
                    }
                    createPayload.data[key] = {
                        connect: this.makeIdConnect(relationInfo.idFields, data.data.id),
                    };
                }

                // make sure ID fields are included for result serialization
                createPayload.include = {
                    ...createPayload.include,
                    [key]: { select: { [this.makeDefaultIdKey(relationInfo.idFields)]: true } },
                };
            }
        }

        // include IDs of relation fields so that they can be serialized.
        this.includeRelationshipIds(type, createPayload, 'include');

        const entity = await (client as any)[type].create(createPayload);
        return {