Method handleRequest

packages/server/src/api/rest/index.ts:448–665

({ client, method, path, query, requestBody }: RequestContext<Schema>)

    }

    async handleRequest({ client, method, path, query, requestBody }: RequestContext<Schema>): Promise<Response> {
        method = method.toUpperCase();
        if (!path.startsWith('/')) {
            path = '/' + path;
        }

        try {
            if (path.startsWith('/$procs/')) {
                const proc = path.split('/')[2];
                return await this.processProcedureRequest({ client, method, proc, query, requestBody });
            }

            switch (method) {
                case 'GET': {
                    let match = this.matchUrlPattern(path, UrlPatterns.SINGLE);
                    if (match) {
                        // single resource read
                        return await this.processSingleRead(client, match.type, match.id, query);
                    }
                    match = this.matchUrlPattern(path, UrlPatterns.FETCH_RELATIONSHIP);
                    if (match) {
                        // fetch related resource(s)
                        return await this.processFetchRelated(client, match.type, match.id, match.relationship, query);
                    }

                    match = this.matchUrlPattern(path, UrlPatterns.RELATIONSHIP);
                    if (match) {
                        // read relationship
                        return await this.processReadRelationship(
                            client,
                            match.type,
                            match.id,
                            match.relationship,
                            query,
                        );
                    }

                    // /:type/:id/:relationship/:childId — nested single read
                    match = this.matchUrlPattern(path, UrlPatterns.NESTED_SINGLE);
                    if (match && this.nestedRoutes && this.resolveNestedRelation(match.type, match.relationship)?.isCollection) {
                        return await this.processNestedSingleRead(
                            client,
                            match.type,
                            match.id,
                            match.relationship,
                            match.childId!,
                            query,
                        );
                    }
                    match = this.matchUrlPattern(path, UrlPatterns.COLLECTION);
                    if (match) {
                        // collection read
                        return await this.processCollectionRead(client, match.type, query);
                    }

                    return this.makeError('invalidPath');
                }