Method handleProc

packages/orm/src/client/client-impl.ts:316–369

(name: string, input: unknown)

    }

    private async handleProc(name: string, input: unknown) {
        if (!('procedures' in this.$options) || !this.$options || typeof this.$options.procedures !== 'object') {
            throw createConfigError('Procedures are not configured for the client.');
        }

        const procDef = (this.$schema.procedures ?? {})[name];
        if (!procDef) {
            throw createConfigError(`Procedure "${name}" is not defined in schema.`);
        }

        const procOptions = this.$options.procedures as ProceduresOptions<
            SchemaDef & {
                procedures: Record<string, ProcedureDef>;
            }
        >;
        if (!procOptions[name] || typeof procOptions[name] !== 'function') {
            throw createConfigError(`Procedure "${name}" does not have a handler configured.`);
        }

        // Validate inputs using the same validator infrastructure as CRUD operations.
        const validatedInput = this.inputValidator.validateProcedureInput(name, input);

        const handler = procOptions[name] as Function;

        const invokeWithClient = async (client: any, _input: unknown) => {
            let proceed = async (nextInput: unknown) => {
                const sanitizedNextInput =
                    nextInput && typeof nextInput === 'object' && !Array.isArray(nextInput) ? nextInput : {};

                return handler({ client, ...sanitizedNextInput });
            };

            // apply plugins
            const plugins = [...(client.$options?.plugins ?? [])];
            for (const plugin of plugins) {
                const onProcedure = plugin.onProcedure;
                if (onProcedure) {
                    const _proceed = proceed;
                    proceed = (nextInput: unknown) =>
                        onProcedure({
                            client,
                            name,
                            mutation: !!procDef.mutation,
                            input: nextInput,
                            proceed: (finalInput: unknown) => _proceed(finalInput),
                        }) as Promise<unknown>;
                }
            }

            return proceed(_input);
        };

        return invokeWithClient(this as any, validatedInput);
    }

    async $connect() {
        await this.kysely.connection().execute(async (conn) => {