zudoku 0.1.1-dev.9 → 0.3.0-dev.100

package/src/lib/oas/graphql/index.ts

@@ -0,0 +1,433 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import SchemaBuilder from "@pothos/core";
+import { GraphQLJSON, GraphQLJSONObject } from "graphql-type-json";
+import { createYoga, type YogaServerOptions } from "graphql-yoga";
+import { LRUCache } from "lru-cache";
+import hashit from "object-hash";
+import slugify from "../../util/slugify.js";
+import {
+  HttpMethods,
+  validate,
+  type EncodingObject,
+  type ExampleObject,
+  type OpenAPIDocument,
+  type OperationObject,
+  type ParameterObject,
+  type PathsObject,
+  type SchemaObject,
+  type TagObject,
+} from "../parser/index.js";
+
+export type {
+  EncodingObject,
+  ExampleObject,
+  OpenAPIDocument,
+  OperationObject,
+  ParameterObject,
+  PathsObject,
+  SchemaObject,
+  TagObject,
+};
+
+type OperationLike = {
+  summary?: string | null;
+  operationId?: string | null;
+  path: string;
+  method: string;
+};
+export const slugifyOperation = (operation: OperationLike, tag?: string) => {
+  const summary =
+    (operation.summary ?? "") +
+    (operation.operationId
+      ? "-" +
+        operation.operationId.slice(0, operation.summary ? Infinity : Infinity)
+      : "");
+
+  return slugify(
+    (tag ? tag + "-" : "") +
+      (summary || `${operation.method}-${operation.path}`),
+    { lower: true, trim: true },
+  );
+};
+
+const cache = new LRUCache<string, Promise<OpenAPIDocument>>({
+  ttl: 60 * 10 * 1000,
+  ttlAutopurge: true,
+});
+
+const builder = new SchemaBuilder<{
+  Scalars: {
+    JSON: any;
+    JSONObject: any;
+  };
+  Context: {
+    schema: OpenAPIDocument;
+  };
+}>({});
+
+const JSONScalar = builder.addScalarType("JSON", GraphQLJSON);
+const JSONObjectScalar = builder.addScalarType("JSONObject", GraphQLJSONObject);
+
+const getAllOperations = (paths?: PathsObject, tag?: string) => {
+  return Object.entries(paths ?? {}).flatMap(([path, value]) =>
+    HttpMethods.flatMap((method) => {
+      if (!value?.[method]) return [];
+
+      const operation = value[method] as OperationObject;
+      const pathParameters = value.parameters ?? [];
+      const operationParameters = operation.parameters ?? [];
+
+      // parameters are inherited from the parent path object,
+      // but can be overridden by their `name` and `in` location
+      const parameters = [
+        ...pathParameters.filter(
+          // remove path parameters that are already defined in the operation
+          (pp) =>
+            !operationParameters.some(
+              (op) => op.name === pp.name && op.in === pp.in,
+            ),
+        ),
+        ...operationParameters,
+      ];
+
+      return {
+        ...operation,
+        method,
+        path,
+        parameters,
+        tags: operation.tags ?? [],
+        slug: slugifyOperation(
+          {
+            summary: operation.summary,
+            operationId: operation.operationId,
+            path,
+            method,
+          },
+          tag,
+        ),
+      };
+    }),
+  );
+};
+
+const SchemaTag = builder.objectRef<TagObject>("SchemaTag").implement({
+  fields: (t) => ({
+    name: t.exposeString("name", { nullable: true }),
+    description: t.exposeString("description", { nullable: true }),
+    operations: t.field({
+      type: [OperationItem],
+      resolve: (parent, _args, ctx) => {
+        const rootTags = ctx.schema.tags?.map((tag) => tag.name) ?? [];
+
+        return getAllOperations(ctx.schema.paths, parent.name).filter((item) =>
+          parent.name
+            ? item.tags.includes(parent.name)
+            : item.tags.length === 0 ||
+              // If none of the tags are present in the root tags, then show them here
+              item.tags.every((tag) => !rootTags.includes(tag)),
+        );
+      },
+    }),
+  }),
+});
+
+const PathItem = builder
+  .objectRef<{
+    path: string;
+    methods: typeof HttpMethods;
+  }>("PathItem")
+  .implement({
+    fields: (t) => ({
+      path: t.exposeString("path"),
+      methods: t.exposeStringList("methods"),
+    }),
+  });
+
+const TagItem = builder.objectRef<TagObject>("TagItem").implement({
+  fields: (t) => ({
+    name: t.exposeString("name"),
+    description: t.exposeString("description", { nullable: true }),
+  }),
+});
+
+const EncodingItem = builder
+  .objectRef<EncodingObject & { name: string }>("EncodingItem")
+  .implement({
+    fields: (t) => ({
+      name: t.exposeString("name"),
+      contentType: t.exposeString("contentType", { nullable: true }),
+      headers: t.expose("headers", { type: JSONObjectScalar, nullable: true }),
+      style: t.exposeString("style", { nullable: true }),
+      explode: t.exposeBoolean("explode", { nullable: true }),
+      allowReserved: t.exposeBoolean("allowReserved", { nullable: true }),
+    }),
+  });
+
+const ExampleItem = builder
+  .objectRef<ExampleObject & { name: string }>("ExampleItem")
+  .implement({
+    fields: (t) => ({
+      name: t.exposeString("name"),
+      summary: t.exposeString("summary", { nullable: true }),
+      description: t.exposeString("description", { nullable: true }),
+      value: t.exposeString("value", { nullable: true }),
+      externalValue: t.exposeString("externalValue", { nullable: true }),
+    }),
+  });
+
+const ParameterIn = builder.enumType("ParameterIn", {
+  values: ["query", "header", "path", "cookie"] as const,
+});
+
+const ParameterItem = builder
+  .objectRef<ParameterObject>("ParameterItem")
+  .implement({
+    fields: (t) => ({
+      name: t.exposeString("name"),
+      in: t.field({
+        type: ParameterIn,
+        resolve: (parent) => parent.in as typeof ParameterIn.$inferType,
+      }),
+      description: t.exposeString("description", { nullable: true }),
+      required: t.exposeBoolean("required", { nullable: true }),
+      deprecated: t.exposeBoolean("deprecated", { nullable: true }),
+      allowEmptyValue: t.exposeBoolean("allowEmptyValue", { nullable: true }),
+      style: t.exposeString("style", { nullable: true }),
+      explode: t.exposeBoolean("explode", { nullable: true }),
+      allowReserved: t.exposeBoolean("allowReserved", { nullable: true }),
+      examples: t.field({
+        type: [ExampleItem],
+        resolve: (parent) =>
+          Object.entries(parent.examples ?? {}).map(([name, value]) => ({
+            name,
+            ...(typeof value === "string" ? { value } : value),
+          })),
+        nullable: true,
+      }),
+      schema: t.expose("schema", { type: JSONScalar, nullable: true }),
+    }),
+  });
+
+const MediaTypeItem = builder
+  .objectRef<{
+    mediaType: string;
+    schema: any;
+    examples: Array<ExampleObject & { name: string }>;
+    encoding?: Array<EncodingObject & { name: string }>;
+  }>("MediaTypeObject")
+  .implement({
+    fields: (t) => ({
+      mediaType: t.exposeString("mediaType"),
+      schema: t.expose("schema", { type: JSONScalar, nullable: true }),
+      examples: t.expose("examples", { type: [ExampleItem], nullable: true }),
+      encoding: t.expose("encoding", { type: [EncodingItem], nullable: true }),
+    }),
+  });
+
+const RequestBodyObject = builder
+  .objectRef<{
+    description?: string;
+    required?: boolean;
+    content: Array<{
+      mediaType: string;
+      schema: any;
+      examples: Array<ExampleObject & { name: string }>;
+      encoding?: Array<EncodingObject & { name: string }>;
+    }>;
+  }>("RequestBodyObject")
+  .implement({
+    fields: (t) => ({
+      description: t.exposeString("description", { nullable: true }),
+      content: t.expose("content", { type: [MediaTypeItem], nullable: true }),
+      required: t.exposeBoolean("required", { nullable: true }),
+    }),
+  });
+
+const ResponseItem = builder
+  .objectRef<{
+    statusCode: string;
+    description: string;
+    content: Array<{
+      mediaType: string;
+      schema: any;
+      examples: Array<ExampleObject & { name: string }>;
+    }>;
+    headers?: any;
+    links?: any;
+  }>("ResponseItem")
+  .implement({
+    fields: (t) => ({
+      statusCode: t.exposeString("statusCode"),
+      description: t.exposeString("description"),
+      content: t.expose("content", { type: [MediaTypeItem], nullable: true }),
+      headers: t.expose("headers", { type: JSONScalar, nullable: true }),
+      links: t.expose("links", { type: JSONScalar, nullable: true }),
+    }),
+  });
+
+const OperationItem = builder
+  .objectRef<
+    OperationObject & { path: string; method: string; slug: string }
+  >("OperationItem")
+  .implement({
+    fields: (t) => ({
+      slug: t.exposeString("slug"),
+      path: t.exposeString("path"),
+      method: t.exposeString("method"),
+      operationId: t.exposeString("operationId", { nullable: true }),
+      summary: t.exposeString("summary", { nullable: true }),
+      description: t.exposeString("description", { nullable: true }),
+      contentTypes: t.stringList({
+        resolve: (parent) => Object.keys(parent.requestBody?.content ?? {}),
+      }),
+      parameters: t.expose("parameters", {
+        type: [ParameterItem],
+        nullable: true,
+      }),
+      requestBody: t.field({
+        type: RequestBodyObject,
+        resolve: (parent) => ({
+          description: parent.requestBody?.description,
+          required: parent.requestBody?.required,
+          content: Object.entries(parent.requestBody?.content ?? {}).map(
+            ([mediaType, content]) => ({
+              mediaType,
+              schema: content.schema,
+              examples: Object.entries(content.examples ?? {}).map(
+                ([name, value]) => ({ name, ...value }),
+              ),
+              encoding: Object.entries(content.encoding ?? {}).map(
+                ([name, value]) => ({ name, ...value }),
+              ),
+            }),
+          ),
+        }),
+        nullable: true,
+      }),
+      responses: t.field({
+        type: [ResponseItem],
+        resolve: (parent) => {
+          return Object.entries(parent.responses ?? {}).map(
+            ([statusCode, response]) => ({
+              statusCode,
+              description: response.description,
+              content: Object.entries(response.content ?? {}).map(
+                ([mediaType, mediaTypeObject]) => ({
+                  mediaType,
+                  schema: mediaTypeObject.schema,
+                  examples: Object.entries(mediaTypeObject.examples ?? {}).map(
+                    ([name, value]) => ({ name, ...value }),
+                  ),
+                }),
+              ),
+              headers: response.headers,
+              links: response.links,
+            }),
+          );
+        },
+      }),
+      tags: t.field({
+        type: [TagItem],
+        resolve: (parent, _, ctx) =>
+          parent.tags?.map((tag) => ({
+            name: tag,
+            description: ctx.schema.tags?.find((t) => t.name === tag)
+              ?.description,
+          })),
+        nullable: true,
+      }),
+      deprecated: t.exposeBoolean("deprecated", { nullable: true }),
+    }),
+  });
+
+const Schema = builder.objectRef<OpenAPIDocument>("Schema").implement({
+  fields: (t) => ({
+    openapi: t.string({ resolve: (root) => root.openapi }),
+    url: t.string({ resolve: (root) => root.servers?.at(0)?.url ?? "/" }),
+    title: t.string({ resolve: (root) => root.info.title }),
+    version: t.string({ resolve: (root) => root.info.version }),
+    description: t.string({
+      resolve: (root) => root.info.description,
+      nullable: true,
+    }),
+    paths: t.field({
+      type: [PathItem],
+      resolve: (root) =>
+        Object.entries(root.paths ?? {}).map(([path, value]) => ({
+          path,
+          methods: Object.keys(value!) as typeof HttpMethods,
+        })),
+    }),
+    tags: t.field({
+      args: {
+        name: t.arg.string(),
+      },
+      type: [SchemaTag],
+      resolve: (root, args) =>
+        [...(root.tags ?? []), { name: "" }].filter(
+          (tag) => !args.name || args.name === tag.name,
+        ),
+    }),
+    operations: t.field({
+      type: [OperationItem],
+      args: {
+        path: t.arg.string(),
+        method: t.arg.string(),
+        operationId: t.arg.string(),
+        tag: t.arg.string(),
+      },
+      resolve: (parent, args) =>
+        getAllOperations(parent.paths).filter(
+          (item) =>
+            (!args.operationId || item.operationId === args.operationId) &&
+            (!args.path || item.path === args.path) &&
+            (!args.method || item.method === args.method) &&
+            (!args.tag || item.tags.includes(args.tag)),
+        ),
+    }),
+  }),
+});
+
+const loadOpenAPISchema = async (input: NonNullable<unknown>) => {
+  const hash = hashit(input);
+
+  if (cache.has(hash)) {
+    return cache.get(hash)!;
+  }
+
+  const schema = validate(input);
+
+  cache.set(hash, schema);
+
+  return schema;
+};
+
+const SchemaSource = builder.enumType("SchemaType", {
+  values: ["url", "json", "yaml"] as const,
+});
+
+builder.queryType({
+  fields: (t) => ({
+    // https://tan-cow-main-bce8a06.d2.zuplo.dev/openapi
+    schema: t.field({
+      type: Schema,
+      args: {
+        type: t.arg({ type: SchemaSource, required: true }),
+        input: t.arg({ type: JSONScalar, required: true }),
+      },
+      resolve: async (_, args, ctx) => {
+        const schema = await loadOpenAPISchema(args.input!);
+        // for easier access of the whole schema in children resolvers
+        ctx.schema = schema;
+
+        return schema;
+      },
+    }),
+  }),
+});
+
+export const schema = builder.toSchema();
+
+export const createGraphQLServer = (
+  options?: Omit<YogaServerOptions<any, any>, "schema">,
+) => createYoga({ schema, ...options });

package/src/lib/oas/parser/index.ts

@@ -0,0 +1,115 @@
+import { GraphQLError } from "graphql/error/index.js";
+import { OpenAPIV3, type OpenAPIV3_1 } from "openapi-types";
+import { dereference, type JSONSchema } from "./dereference/index.js";
+import { upgradeSchema } from "./upgrade/index.js";
+
+type ReferenceObject = OpenAPIV3_1.ReferenceObject;
+type DeepOmitReference<T> = T extends ReferenceObject
+  ? never
+  : T extends object
+    ? { [K in keyof T]: DeepOmitReference<T[K]> }
+    : T;
+
+export type OpenAPIDocument = DeepOmitReference<OpenAPIV3_1.Document>;
+export type ResponseObject = DeepOmitReference<OpenAPIV3_1.ResponseObject>;
+export type OperationObject = DeepOmitReference<OpenAPIV3_1.OperationObject>;
+export type PathsObject = DeepOmitReference<OpenAPIV3_1.PathsObject>;
+export type PathItemObject = DeepOmitReference<OpenAPIV3_1.PathItemObject>;
+export type ParameterObject = DeepOmitReference<OpenAPIV3_1.ParameterObject>;
+export type TagObject = DeepOmitReference<OpenAPIV3_1.TagObject>;
+export type ExampleObject = DeepOmitReference<OpenAPIV3_1.ExampleObject>;
+export type EncodingObject = DeepOmitReference<OpenAPIV3_1.EncodingObject>;
+export type SchemaObject = DeepOmitReference<OpenAPIV3_1.SchemaObject>;
+
+export const HttpMethods = Object.values(OpenAPIV3.HttpMethods);
+
+// class ValidationError extends Error {
+//   constructor(public errors: OutputUnit[]) {
+//     super("Validation error");
+//   }
+// }
+
+// const getValidator = async (openApiVersion: string) => {
+//   if (openApiVersion.startsWith("3.0")) {
+//     const schema = (await import("./schemas/v3.0.json")) as any;
+//     return new Validator(schema, "4");
+//   }
+//   if (openApiVersion.startsWith("3.1")) {
+//     const schema = (await import("./schemas/v3.1.json")) as any;
+//     return new Validator(schema as any, "2020-12");
+//   }
+
+//   throw new Error(`Unsupported OpenAPI version: ${openApiVersion}`);
+// };
+
+const parseSchemaInput = async (
+  schemaInput: unknown,
+): Promise<JSONSchema & { openapi?: string }> => {
+  if (typeof schemaInput === "string") {
+    if (schemaInput.trim().startsWith("{")) {
+      try {
+        return JSON.parse(schemaInput);
+      } catch (err) {
+        throw new GraphQLError("Invalid JSON schema", {
+          originalError: err,
+        });
+      }
+    }
+    if (schemaInput.includes("://")) {
+      let response;
+      try {
+        response = await fetch(schemaInput, {
+          cache: "force-cache",
+        });
+      } catch (err) {
+        throw new GraphQLError("Failed to fetch schema", {
+          originalError: err,
+        });
+      }
+
+      if (!response.ok) {
+        throw new GraphQLError(
+          `Failed to fetch schema: ${response.statusText}`,
+        );
+      }
+
+      try {
+        return (await response.json()) as JSONSchema;
+      } catch (err) {
+        throw new GraphQLError("Fetched invalid JSON schema", {
+          originalError: err,
+        });
+      }
+    }
+    const yaml = await import("yaml");
+    const parsed = yaml.parse(schemaInput);
+
+    if (typeof parsed === "object") return parsed;
+  }
+
+  if (typeof schemaInput === "object") return schemaInput as JSONSchema;
+
+  throw new GraphQLError("Unsupported schema input: " + schemaInput);
+};
+
+/**
+ * Validates, dereferences and upgrades the OpenAPI schema (to v3.1) if necessary.
+ */
+export const validate = async (schemaInput: unknown) => {
+  const schema = await parseSchemaInput(schemaInput);
+
+  if (!schema.openapi) {
+    throw new GraphQLError("OpenAPI version is not defined");
+  }
+
+  // const validator = await getValidator(schema.openapi);
+  // const result = validator.validate(schema);
+  //
+  // if (!result.valid) {
+  //   throw new ValidationError(result.errors);
+  // }
+
+  const dereferenced = await dereference(schema);
+
+  return upgradeSchema(dereferenced);
+};

package/src/lib/plugins/api-keys/CreateApiKey.tsx

@@ -0,0 +1,94 @@
+import { useMutation } from "@tanstack/react-query";
+import { useForm } from "react-hook-form";
+import { Link, useNavigate } from "react-router-dom";
+import { useZudoku } from "../../components/context/ZudokuContext.js";
+import {
+  Select,
+  SelectContent,
+  SelectGroup,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "../../components/Select.js";
+import { Button } from "../../ui/Button.js";
+import { Input } from "../../ui/Input.js";
+import { ApiKeyService } from "./index.js";
+
+type CreateApiKey = { description: string; expiresOn?: string };
+
+export const CreateApiKey = ({ service }: { service: ApiKeyService }) => {
+  const context = useZudoku();
+  const navigate = useNavigate();
+  const form = useForm<CreateApiKey>({
+    defaultValues: {
+      expiresOn: "30",
+    },
+  });
+  const createKeyMutation = useMutation({
+    mutationFn: ({ description, expiresOn }: CreateApiKey) => {
+      if (!service.createKey) {
+        throw new Error("deleteKey not implemented");
+      }
+
+      const expiresOnDate =
+        expiresOn !== "never" ? addDaysToDate(Number(expiresOn)) : undefined;
+
+      return service.createKey(
+        { description: description, expiresOn: expiresOnDate },
+        context,
+      );
+    },
+    onSuccess: () => navigate("/settings/api-keys/"),
+  });
+
+  if (!service.createKey) {
+    return null;
+  }
+
+  return (
+    <div className="max-w-screen-lg pt-[--padding-content-top] pb-[--padding-content-bottom]">
+      <div className="flex justify-between mb-4 border-b pb-1">
+        <h1 className="font-medium text-2xl">New API Key</h1>
+      </div>
+      <form
+        onSubmit={form.handleSubmit((data) => createKeyMutation.mutate(data))}
+      >
+        <div className="flex gap-2 flex-col">
+          Note
+          <Input {...form.register("description")} />
+          Expiration
+          <Select
+            onValueChange={(value) => form.setValue("expiresOn", value)}
+            defaultValue={form.getValues("expiresOn")}
+          >
+            <SelectTrigger>
+              <SelectValue />
+            </SelectTrigger>
+            <SelectContent>
+              <SelectGroup>
+                {[7, 30, 60, 90].map((option) => (
+                  <SelectItem value={String(option)} key={option}>
+                    {option} days
+                  </SelectItem>
+                ))}
+                <SelectItem value="never">Never</SelectItem>
+              </SelectGroup>
+            </SelectContent>
+          </Select>
+          <div className="flex gap-2">
+            <Button>Generate Key</Button>
+            <Button variant="outline" asChild>
+              <Link to="/settings/api-keys/">Cancel</Link>
+            </Button>
+          </div>
+        </div>
+      </form>
+    </div>
+  );
+};
+
+const addDaysToDate = (days: number): string => {
+  const date = new Date();
+  date.setDate(date.getDate() + days);
+  return date.toISOString();
+};

package/src/lib/plugins/api-keys/ProtectedRoute.tsx

@@ -0,0 +1,29 @@
+import { Outlet } from "react-router-dom";
+import { useAuth } from "../../authentication/hook.js";
+import { DeveloperHint } from "../../components/DeveloperHint.js";
+import { Button } from "../../ui/Button.js";
+
+export const ProtectedRoute = () => {
+  const auth = useAuth();
+
+  // TODO: should we suspend here somehow?
+  if (auth.isAuthEnabled && auth.isPending) {
+    return null;
+  }
+
+  return auth.isAuthenticated ? (
+    <Outlet />
+  ) : !auth.isAuthEnabled ? (
+    <div className="flex flex-col justify-center gap-2 items-center h-1/2">
+      <DeveloperHint className="max-w-[600px]">
+        Authentication needs to be enabled for API keys to work. Enable it in
+        your Zudoku configuration under <code>authentication</code>.
+      </DeveloperHint>
+    </div>
+  ) : (
+    <div className="flex flex-col justify-center gap-2 items-center h-1/2">
+      Please login first to view this page
+      <Button onClick={() => auth.login()}>Login</Button>
+    </div>
+  );
+};