Function delete

packages/orm/src/client/crud/operations/base.ts:2353–2427

(
        kysely: AnyKysely,
        model: string,
        where: any,
        limit?: number,
        filterModel?: string,
        fieldsToReturn?: readonly string[],
    )

    // #endregion

    protected async delete(
        kysely: AnyKysely,
        model: string,
        where: any,
        limit?: number,
        filterModel?: string,
        fieldsToReturn?: readonly string[],
    ): Promise<QueryResult<unknown>> {
        filterModel ??= model;

        const modelDef = this.requireModel(model);

        if (modelDef.baseModel) {
            if (limit !== undefined) {
                throw createNotSupportedError('Deleting with a limit is not supported for polymorphic models');
            }
            // just delete base and it'll cascade back to this model
            return this.processBaseModelDelete(kysely, modelDef.baseModel, where, limit, filterModel);
        }

        fieldsToReturn = fieldsToReturn ?? requireIdFields(this.schema, model);

        let needIdFilter = false;

        if (limit !== undefined && !this.dialect.supportsDeleteWithLimit) {
            // if the dialect doesn't support delete with limit natively, we'll
            // simulate it by filtering by id with a limit
            needIdFilter = true;
        }

        if (modelDef.isDelegate || modelDef.baseModel) {
            // if the model is in a delegate hierarchy, we'll need to filter by
            // id because the filter may involve fields in different models in
            // the hierarchy
            needIdFilter = true;
        }

        const deleteFilter = needIdFilter
            ? (eb: ExpressionBuilder<any, any>) =>
                  eb(
                      eb.refTuple(
                          // @ts-expect-error
                          ...this.buildIdFieldRefs(kysely, model),
                      ),
                      'in',
                      // the outer "select *" is needed to isolate the sub query (as needed for dialects like mysql)
                      eb
                          .selectFrom(
                              this.dialect
                                  .buildSelectModel(filterModel, filterModel)
                                  .where(() => this.dialect.buildFilter(filterModel, filterModel, where))
                                  .select(this.buildIdFieldRefs(kysely, filterModel))
                                  .$if(limit !== undefined, (qb) => qb.limit(limit!))
                                  .as('$sub'),
                          )
                          .selectAll(),
                  )
            : () => this.dialect.buildFilter(model, model, where);