export function registerSessionRoutes()

in src/platform/plugins/shared/data/server/search/routes/session.ts [36:398]
345 lines of code
14 McCabe index (conditional complexity)

export function registerSessionRoutes(router: DataPluginRouter, logger: Logger): void {
  router.versioned
    .post({
      path: pathPrefix,
      access,
      security: {
        authz: { requiredPrivileges },
      },
    })
    .addVersion(
      {
        version,
        validate: {
          request: {
            body: schema.object({
              sessionId: schema.string(),
              name: schema.string(),
              appId: schema.string(),
              expires: schema.maybe(schema.string()),
              locatorId: schema.string(),
              initialState: schema.maybe(schema.object({}, { unknowns: 'allow' })),
              restoreState: schema.maybe(schema.object({}, { unknowns: 'allow' })),
            }),
          },
          response: {
            200: {
              body: () => schema.maybe(searchSessionSchema()),
            },
          },
        },
      },
      async (context, request, res) => {
        const { sessionId, name, expires, initialState, restoreState, appId, locatorId } =
          request.body;

        try {
          const searchContext = await context.search;

          const response = await searchContext.saveSession(sessionId, {
            name,
            appId,
            expires,
            locatorId,
            initialState,
            restoreState,
          });

          const body: SearchSessionRestResponse | undefined = idAndAttrsOnly(response);

          return res.ok({ body });
        } catch (err) {
          logger.error(err);
          return reportServerError(res, err);
        }
      }
    );

  router.versioned
    .get({
      path: `${pathPrefix}/{id}`,
      access,
      security: {
        authz: { requiredPrivileges },
      },
    })
    .addVersion(
      {
        version,
        validate: {
          request: {
            params: schema.object({
              id: schema.string(),
            }),
          },
          response: {
            200: {
              body: searchSessionSchema,
            },
          },
        },
      },
      async (context, request, res) => {
        const { id } = request.params;
        try {
          const searchContext = await context.search;
          const response: SearchSessionRestResponse = await searchContext!.getSession(id);
          const body = idAndAttrsOnly(response);

          return res.ok({ body });
        } catch (e) {
          const err = e.output?.payload || e;
          logger.error(err);
          return reportServerError(res, err);
        }
      }
    );

  router.versioned
    .get({
      path: `${pathPrefix}/{id}/status`,
      access,
      security: {
        authz: { requiredPrivileges },
      },
    })
    .addVersion(
      {
        version,
        validate: {
          request: {
            params: schema.object({
              id: schema.string(),
            }),
          },
          response: {
            200: {
              body: searchSessionStatusSchema,
            },
          },
        },
      },
      async (context, request, res) => {
        const { id } = request.params;
        try {
          const searchContext = await context.search;
          const response: SearchSessionStatusRestResponse = await searchContext!.getSessionStatus(
            id
          );

          return res.ok({
            body: response,
          });
        } catch (e) {
          const err = e.output?.payload || e;
          logger.error(err);
          return reportServerError(res, err);
        }
      }
    );

  router.versioned
    .post({
      path: `${pathPrefix}/_find`,
      access,
      security: {
        authz: { requiredPrivileges },
      },
    })
    .addVersion(
      {
        version,
        validate: {
          request: {
            body: schema.object({
              page: schema.maybe(schema.number()),
              perPage: schema.maybe(schema.number()),
              sortField: schema.maybe(schema.string()),
              sortOrder: schema.maybe(
                schema.oneOf([schema.literal('desc'), schema.literal('asc')])
              ),
              filter: schema.maybe(schema.string()),
              searchFields: schema.maybe(schema.arrayOf(schema.string())),
              search: schema.maybe(schema.string()),
            }),
          },
          response: {
            200: {
              body: searchSessionsFindSchema,
            },
          },
        },
      },
      async (context, request, res) => {
        const { page, perPage, sortField, sortOrder, filter, searchFields, search } = request.body;
        try {
          const searchContext = await context.search;
          const response: SearchSessionsFindRestResponse = await searchContext!.findSessions({
            page,
            perPage,
            sortField,
            sortOrder,
            filter,
            searchFields,
            search,
          });

          const body = {
            total: response.total,
            saved_objects: response.saved_objects.map(idAndAttrsOnly),
            statuses: response.statuses,
          };

          return res.ok({ body });
        } catch (err) {
          logger.error(err);
          return reportServerError(res, err);
        }
      }
    );

  router.versioned
    .delete({
      path: `${pathPrefix}/{id}`,
      access,
      security: {
        authz: { requiredPrivileges },
      },
    })
    .addVersion(
      {
        version,
        validate: {
          request: {
            params: schema.object({
              id: schema.string(),
            }),
          },
        },
      },
      async (context, request, res) => {
        const { id } = request.params;
        try {
          const searchContext = await context.search;
          await searchContext.deleteSession(id);

          return res.ok();
        } catch (e) {
          const err = e.output?.payload || e;
          logger.error(err);
          return reportServerError(res, err);
        }
      }
    );

  router.versioned
    .post({
      path: `${pathPrefix}/{id}/cancel`,
      access,
      security: {
        authz: { requiredPrivileges },
      },
    })
    .addVersion(
      {
        version,
        validate: {
          request: {
            params: schema.object({
              id: schema.string(),
            }),
          },
        },
      },
      async (context, request, res) => {
        const { id } = request.params;
        try {
          const searchContext = await context.search;
          await searchContext.cancelSession(id);

          return res.ok();
        } catch (e) {
          const err = e.output?.payload || e;
          logger.error(err);
          return reportServerError(res, err);
        }
      }
    );

  router.versioned
    .put({
      path: `${pathPrefix}/{id}`,
      access,
      security: {
        authz: { requiredPrivileges },
      },
    })
    .addVersion(
      {
        version,
        validate: {
          request: {
            params: schema.object({
              id: schema.string(),
            }),
            body: schema.object({
              name: schema.maybe(schema.string()),
              expires: schema.maybe(schema.string()),
            }),
          },
          response: {
            200: {
              body: searchSessionsUpdateSchema,
            },
          },
        },
      },
      async (context, request, res) => {
        const { id } = request.params;
        const { name, expires } = request.body;
        try {
          const searchContext = await context.search;
          const response: SearchSessionsUpdateRestResponse = await searchContext.updateSession(id, {
            name,
            expires,
          });
          return res.ok({
            body: response,
          });
        } catch (err) {
          logger.error(err);
          return reportServerError(res, err);
        }
      }
    );

  router.versioned
    .post({
      path: `${pathPrefix}/{id}/_extend`,
      access,
      security: {
        authz: { requiredPrivileges },
      },
    })
    .addVersion(
      {
        version,
        validate: {
          request: {
            params: schema.object({
              id: schema.string(),
            }),
            body: schema.object({
              expires: schema.string(),
            }),
          },
          response: {
            200: {
              body: searchSessionsUpdateSchema,
            },
          },
        },
      },
      async (context, request, res) => {
        const { id } = request.params;
        const { expires } = request.body;
        try {
          const searchContext = await context.search;
          const response: SearchSessionsUpdateRestResponse = await searchContext.extendSession(
            id,
            new Date(expires)
          );

          return res.ok({
            body: response,
          });
        } catch (e) {
          const err = e.output?.payload || e;
          logger.error(err);
          return reportServerError(res, err);
        }
      }
    );
}