rquest/src/lib/state.svelte.ts

import { Channel, invoke } from "@tauri-apps/api/core";
import type {
  Workspace,
  WorkspaceEntryBase,
  RequestBody,
  WorkspaceEntry,
  WorkspaceEnvironment,
  EnvVariable,
  RequestUrl,
  RequestHeader,
  PathParam,
  Authentication,
  AuthType,
  HttpResponse,
  ResponseResult,
  QueryParam,
} from "./types";
import { getSetting, setSetting } from "./settings.svelte";

export type WorkspaceState = {
  /**
   * Currently selected workspace.
   */
  workspace: Workspace | null;

  /**
   * Currently selected workspace entry.
   */
  entry: WorkspaceEntry | null;

  /**
   * Workspace root entries.
   */
  roots: number[];

  /**
   * Workspace entry root => children mappings.
   */
  children: Record<number, number[]>;

  /**
   * All workspace entries.
   */
  indexes: Record<number, WorkspaceEntry>;

  /**
   * Currently selected workspace environments.
   */
  environments: WorkspaceEnvironment[];

  /**
   * Currently selected environment.
   */
  environment: WorkspaceEnvironment | null;

  /**
   * All workspace authentication schemes.
   */
  auth: Authentication[];

  /**
   * Set of pending sent requests.
   */
  pendingRequests: number[];

  /**
   * Maps request IDs to their latest response.
   */
  responses: Record<number, HttpResponse>;
};

export const state: WorkspaceState = $state({
  workspace: null,
  entry: null,
  roots: [],
  children: {},
  indexes: {},
  environments: [],
  environment: null,
  auth: [],
  pendingRequests: [],
  responses: {},
});

const index = (entry: WorkspaceEntry) => {
  console.log("indexing", entry);
  state.indexes[entry.id] = entry;

  if (entry.parent_id != null) {
    if (state.children[entry.parent_id]) {
      state.children[entry.parent_id].push(entry.id);
    } else {
      state.children[entry.parent_id] = [entry.id];
    }
  } else {
    state.roots.push(entry.id);
  }
};

function reset() {
  state.children = {};
  state.indexes = {};
  state.roots = [];
  state.entry = null;
  state.environment = null;
  state.environments = [];
  state.auth = [];
  state.pendingRequests = [];
  state.responses = {};
}

/**
 * Given a root entry, traverse its children depth first and call `fn` on each, including
 * the root.
 */
export function traverseEntries(id: number, fn: (e: WorkspaceEntry) => void) {
  if (state.indexes[id] == null) {
    return;
  }

  fn(state.indexes[id]);

  if (state.children[id] == null) {
    return;
  }

  for (const child of state.children[id]) {
    traverseEntries(child, fn);
  }
}

export async function selectEnvironment(
  id: number | null,
  save: boolean = true,
) {
  if (id === null) {
    state.environment = null;
    let env = await getSetting("lastEnvironment");
    if (env) {
      env[state.workspace!!.id] = null;
    } else {
      env = { [state.workspace!!.id]: null };
    }
    setSetting("lastEnvironment", env);
    return;
  }

  state.environment = state.environments.find((e) => e.id === id) ?? null;

  console.debug("selected environment:", state.environment?.name);

  if (!save) {
    return;
  }

  let env = await getSetting("lastEnvironment");
  if (env) {
    env[state.workspace!!.id] = id;
  } else {
    env = { [state.workspace!!.id]: id };
  }

  setSetting("lastEnvironment", env);
}

export function selectWorkspace(ws: Workspace) {
  console.debug("selecting workspace:", ws.name);
  state.workspace = ws;
}

export async function selectEntry(id: number) {
  const entry = await invoke<WorkspaceEntryResponse>("get_workspace_entry", {
    entryId: id,
  });

  switch (entry.type) {
    case "Collection": {
      state.entry = entry.data;
      break;
    }
    case "Request": {
      state.entry = {
        ...entry.data.entry,
        method: entry.data.method,
        url: entry.data.url,
        headers: entry.data.headers,
        body: entry.data.body,
        path: entry.data.path_params,
        query: entry.data.query_params,
      };
      break;
    }
  }

  console.log("selected entry:", $state.snapshot(state.entry));

  if (state.entry.parent_id != null) {
    let parent = state.indexes[state.entry.parent_id];
    while (parent) {
      parent.open = true;
      if (parent.parent_id === null) {
        break;
      }
      parent = state.indexes[parent.parent_id];
    }
  }

  if (state.entry.type === "Request") {
    expandUrl()
      .then(() =>
        console.debug(
          "expanded URL:",
          $state.snapshot(state.entry.expandedUrl),
        ),
      )
      .catch((e) => {
        console.error("error expanding URL", e);
      });
  }
}

// COMMANDS

export async function createWorkspace(name: string): Promise<Workspace> {
  return invoke<Workspace>("create_workspace", { name });
}

export async function listWorkspaces(): Promise<Workspace[]> {
  return invoke<Workspace[]>("list_workspaces");
}

export async function loadWorkspace(ws: Workspace) {
  reset();

  state.workspace = ws;

  const entries = await invoke<WorkspaceEntryBase[]>("list_workspace_entries", {
    id: state.workspace.id,
  });

  for (const entry of entries) {
    // if (entry.type === "Request") {
    // } else {
    index(entry);
    // }
  }

  await loadEnvironments(state.workspace.id);
  await loadAuths(state.workspace.id);
}

export function createRequest(parentId?: number) {
  if (state.workspace == null) {
    console.warn("create request called with no active workspace");
    return;
  }

  const data = {
    Request: {
      name: "",
      workspace_id: state.workspace.id,
      parent_id: parentId,
      method: "GET",
      url: "",
      auth_inherit: parentId !== undefined,
    },
  };

  invoke<WorkspaceEntryBase>("create_workspace_entry", {
    data,
  }).then((entry) => {
    index(entry);
    selectEntry(entry.id);
    console.log("request created:", entry);
  });
}

export function createCollection(parentId?: number) {
  if (state.workspace == null) {
    console.warn("create collection called with no active workspace");
    return;
  }

  const data = {
    Collection: {
      name: "",
      workspace_id: state.workspace.id,
      parent_id: parentId,
      auth_inherit: parentId !== undefined,
    },
  };
  invoke<WorkspaceEntryBase>("create_workspace_entry", {
    data,
  }).then((entry) => {
    index(entry);
    selectEntry(entry.id);
    console.log("collection created:", entry);
  });
}

export async function loadEnvironments(workspaceId: number) {
  state.environments = await invoke<WorkspaceEnvironment[]>(
    "list_environments",
    { workspaceId },
  );
  const lastEnv = await getSetting("lastEnvironment");
  if (lastEnv && lastEnv[workspaceId] !== undefined) {
    selectEnvironment(lastEnv[workspaceId], false);
  }
}

export async function loadAuths(workspaceId: number) {
  state.auth = await invoke<Authentication[]>("list_auth", { workspaceId });
}

export async function createEnvironment(workspaceId: number, name: string) {
  console.debug("creating environment in", workspaceId);
  const env = await invoke<WorkspaceEnvironment>("create_env", {
    workspaceId,
    name,
  });
  state.environment = env;
  state.environments.push(state.environment);
}

export async function updateEnvironment() {
  if (!state.environment) {
    console.warn("attempted to persist null env");
    return;
  }

  console.debug("updating environment", state.environment);

  await invoke("update_env", {
    id: state.environment.id,
    name: state.environment.name,
  });
}

export async function sendRequest(): Promise<void> {
  const reqId = state.entry!!.id;

  if (state.pendingRequests.includes(reqId)) {
    console.warn("request is already pending", reqId);
  }

  console.log("sending request", reqId);

  const onComplete = new Channel<ResponseResult>();

  console.time("request-" + reqId);

  onComplete.onmessage = (response) => {
    console.log("received response", response);

    switch (response.type) {
      case "Ok": {
        state.responses[state.entry!!.id] = response.data;
        console.log(state.responses);
        break;
      }
      case "Err": {
        console.error("received response error", response.data);
        break;
      }
      default: {
        console.error("unrecognized response type", response.type);
        break;
      }
    }

    console.timeEnd("request-" + reqId);

    state.pendingRequests = state.pendingRequests.filter((id) => id !== reqId);
  };

  await invoke<HttpResponse>("send_request", {
    reqId,
    envId: state.environment?.id,
    onComplete,
  });

  state.pendingRequests.push(reqId);
}

export async function cancelRequest(): Promise<void> {
  if (!state.pendingRequests.includes(state.entry!!.id)) {
    console.warn("nothing to cancel!");
    return;
  }

  console.log("cancelling request");

  await invoke("cancel_request", { reqId: state.entry!!.id });

  console.timeEnd("request-" + state.entry!!.id);

  state.pendingRequests = state.pendingRequests.filter(
    (id) => id !== state.entry!!.id,
  );
}

export async function updateEntryName(name: string) {
  if (!state.entry) {
    console.warn("attempted to persist null entry");
    return;
  }

  console.debug(state.entry.id, "updating entry name to", name);

  await invoke("update_workspace_entry", {
    entryId: state.entry.id,
    name,
  });

  state.indexes[state.entry.id].name = name;
}

/**
 * Whether the URL string was edited directly in the URL bar,
 * in a path parameter, or a query parameter.
 */
export type UrlUpdate =
  | { type: "URL"; url: string }
  | { type: "Path"; url: string; param: PathParam }
  | { type: "Query"; url: string; param: QueryParam };

/**
 * Update a request's URL string. If `usePathparams` is true, path entries
 * from state.entry.path will be used to replace those at the same position and should
 * be set to true whenever this is called from an input field of a destructured URL.
 */
export async function updateUrl(up: UrlUpdate) {
  let update;

  switch (up.type) {
    case "URL": {
      update = { URL: up.url };
      break;
    }
    case "Path": {
      update = { Path: [up.url, up.param] };
      break;
    }
    case "Query": {
      update = { Query: [up.url, up.param] };
      break;
    }
  }

  const params = await invoke<{
    url: RequestUrl;
    full: string;
    path: PathParam[];
    query: QueryParam[];
  }>("update_url", {
    entryId: state.entry!!.id,
    update,
  });

  switch (up.type) {
    case "URL": {
      // state.entry.url is already updated
      // Direct URL updates must always fully update the parameters
      state.entry!!.path = params.path;
      state.entry!!.query = params.query;
      break;
    }
    // Path updates are guaranteed not to modify the updated path param position
    // They also guarantee the same amount of path parameters as before the update
    case "Path": {
      state.entry!!.url = params.full;
      state.entry!!.query = params.query;

      let i = 0;
      for (const newParam of params.path) {
        if (newParam.position <= up.param.position) {
          i += 1;
          continue;
        }

        state.entry!!.path[i] = newParam;
        i += 1;
      }

      break;
    }
    // Query updates have the same guarantees as path updates
    case "Query": {
      state.entry!!.url = params.full;

      let i = 0;
      for (const newParam of params.query) {
        if (newParam.position <= up.param.position) {
          i += 1;
          continue;
        }

        state.entry!!.query[i] = newParam;
        i += 1;
      }

      break;
    }
  }

  expandUrl();

  console.debug("updated", $state.snapshot(state.entry));
}

export async function updateQueryParamEnabled(qpId: number) {
  const qpIdx = state.entry.query.findIndex((qp) => qp.id === qpId);

  if (qpIdx === -1) {
    console.warn("query param does not exist!", qpId);
    return;
  }

  const [newQp, url] = await invoke<string>("update_query_param_enabled", {
    reqId: state.entry.id,
    qpId,
    url: state.entry!!.url,
  });

  console.log("updated QP", newQp, url);

  state.entry!!.url = url;
  state.entry.query[qpIdx] = newQp;
}

export async function expandUrl() {
  state.entry!!.expandedUrl = await invoke<string>("expand_url", {
    entryId: state.entry!!.id,
    envId: state.environment?.id,
    url: state.entry!!.url,
  });
}

export async function insertEnvVariable(
  workspaceId: number,
  envId: number,
  name: string = "",
  value: string = "",
  secret: boolean = false,
) {
  const v = await invoke<EnvVariable>("insert_env_var", {
    workspaceId,
    envId,
    name,
    value,
    secret,
  });

  state.environment?.variables.push(v);
}

export async function updateEnvVariable(v: EnvVariable) {
  if (v.name.length === 0 && v.value.length === 0) {
    console.debug("deleting var:", v);

    return deleteEnvVariable(v.id);
  }

  console.debug("updating var:", v);

  return invoke("update_env_var", {
    id: v.id,
    name: v.name,
    value: v.value,
    secret: v.secret,
  });
}

export async function deleteEnvVariable(id: number) {
  await invoke("delete_env_var", { id });
  state.environment!!.variables = state.environment!!.variables.filter(
    (v) => v.id !== id,
  );
}

export async function insertHeader() {
  const header = await invoke("insert_header", {
    entryId: state.entry!!.id,
    insert: { name: "", value: "" },
  });

  state.entry!!.headers.push(header);
}

export async function updateHeader(id: number, name: string, value: string) {
  await invoke("update_header", {
    update: { id, name, value },
  });
  const header = state.entry!!.headers.find((header) => header.id === id);
  header.name = name;
  header.value = value;
}

export async function deleteHeader(id: number) {
  await invoke("delete_header", {
    headerId: id,
  });
  state.entry!!.headers = state.entry!!.headers.filter(
    (header) => header.id !== id,
  );
}

export async function deleteBody() {
  if (state.entry!!.body === null) {
    console.warn("attempted to delete null body", $state.snapshot(state.entry));
    return;
  }

  await invoke("update_request_body", {
    id: state.entry!!.body.id,
    body: { Null: null },
  });

  state.entry.body = null;

  console.debug("Deleted request body");
}

export async function updateBodyContent(content: string, ty: string) {
  if (state.entry!!.body != null) {
    await invoke("update_request_body", {
      id: state.entry!!.body.id,
      body: { Value: { ty, content } },
    });
    state.entry!!.body.content = content;
    state.entry!!.body.ty = ty;
  } else {
    const b = await invoke("insert_request_body", {
      entryId: state.entry!!.id,
      body: { ty, content },
    });
    state.entry!!.body = b;
  }

  console.debug("Updated body content to", $state.snapshot(state.entry!!.body));
}

export async function createAuth(type: AuthType) {
  const auth = await invoke<Authentication>("insert_auth", {
    workspaceId: state.workspace!!.id,
    type,
  });

  console.debug("created auth", auth);

  state.auth.unshift(auth);
}

export async function renameAuth(id: number, name: string) {
  await invoke<Authentication>("rename_auth", {
    id,
    name,
  });
  const auth = state.auth.find((a) => a.id === id);
  auth!!.name = name;
}

export async function updateAuthParams(id: number) {
  const auth = state.auth.find((a) => a.id === id);

  console.debug("updating auth params", $state.snapshot(auth));

  if (!auth) {
    console.warn("Attempted to update non-existing auth", id);
    return;
  }

  console.log($state.snapshot(auth.params));

  await invoke<Authentication>("update_auth", {
    id,
    params: auth.params,
  });
}

export async function deleteAuth(id: number) {
  console.debug("deleting auth", id);

  await invoke("delete_auth", { id });

  state.auth = state.auth.filter((a) => a.id !== id);
}

export async function setEntryAuth(id: number | null, inherit: boolean | null) {
  console.debug("setting entry auth to", id, "inheriting:", inherit);

  await invoke("set_workspace_entry_auth", {
    entryId: state.entry!!.id,
    authId: id,
    inherit,
  });

  state.entry!!.auth = id;
  state.indexes[state.entry!!.id].auth = id;

  if (inherit != null) {
    state.entry!!.auth_inherit = inherit;
    state.indexes[state.entry!!.id].auth_inherit = inherit;
  }
}

type WorkspaceEntryResponse =
  | {
      type: "Collection";
      data: WorkspaceEntryBase;
    }
  | {
      type: "Request";
      data: WorkspaceRequestResponse;
    };

type WorkspaceRequestResponse = {
  entry: WorkspaceEntryBase;
  method: string;
  url: string;
  body: RequestBody | null;
  headers: RequestHeader[];
  path_params: PathParam[];
  query_params: QueryParam[];
};