Function create

packages/orm/src/client/crud/operations/base.ts:380–579

(
        kysely: AnyKysely,
        model: string,
        data: any,
        fromRelation?: FromRelationContext,
        creatingForDelegate = false,
        returnFields?: readonly string[],
    )

    }

    protected async create(
        kysely: AnyKysely,
        model: string,
        data: any,
        fromRelation?: FromRelationContext,
        creatingForDelegate = false,
        returnFields?: readonly string[],
    ): Promise<unknown> {
        const modelDef = this.requireModel(model);

        // additional validations
        if (modelDef.isDelegate && !creatingForDelegate) {
            throw createNotSupportedError(`Model "${model}" is a delegate and cannot be created directly.`);
        }

        let createFields: any = {};
        let updateParent: ((entity: any) => void) | undefined = undefined;

        let m2m: ReturnType<typeof getManyToManyRelation> = undefined;

        if (fromRelation) {
            m2m = getManyToManyRelation(this.schema, fromRelation.model, fromRelation.field);
            if (!m2m) {
                // many-to-many relations are handled after create
                const { ownedByModel, keyPairs } = getRelationForeignKeyFieldPairs(
                    this.schema,
                    fromRelation?.model ?? '',
                    fromRelation?.field ?? '',
                );

                if (!ownedByModel) {
                    // assign fks from parent
                    const parentFkFields = await this.buildFkAssignments(
                        kysely,
                        fromRelation.model,
                        fromRelation.field,
                        fromRelation.ids,
                    );
                    Object.assign(createFields, parentFkFields);
                } else {
                    // record parent fk update after entity is created
                    updateParent = (entity) => {
                        for (const { fk, pk } of keyPairs) {
                            fromRelation.parentUpdates[fk] = entity[pk];
                        }
                    };
                }
            }
        }

        // process the create and handle relations
        const postCreateRelations: Record<string, object> = {};
        for (const [field, value] of Object.entries(data)) {
            const fieldDef = this.requireField(model, field);
            if (isScalarField(this.schema, model, field) || isForeignKeyField(this.schema, model, field)) {
                if (
                    fieldDef.array &&
                    value &&