zudoku 0.1.1-dev.15 → 0.1.1-dev.16

package/src/app/components/navigation/util.ts

@@ -1,38 +0,0 @@
-import { matchPath } from "react-router-dom";
-import type {
-  HrefNavigationCategoryItem,
-  PathNavigationCategoryItem,
-} from "../../core/DevPortalContext.js";
-import {
-  traverseNavigationNode,
-  type NavigationNode,
-} from "../../util/traverseNavigation.js";
-
-export const isPathItem = (
-  item: NavigationNode,
-): item is PathNavigationCategoryItem => "path" in item;
-
-export const isLinkItem = (
-  item: NavigationNode,
-): item is HrefNavigationCategoryItem => "href" in item;
-
-/**
- * Recursively checks if the current item or any of its children are active.
- */
-export const checkHasActiveItem = (
-  item: NavigationNode,
-  locationPath: string,
-  basePath: string,
-) => {
-  return Boolean(
-    traverseNavigationNode(
-      item,
-      (node, fullPath) => {
-        if (isPathItem(node) && matchPath(fullPath, locationPath)) {
-          return true;
-        }
-      },
-      basePath,
-    ),
-  );
-};

package/src/app/core/DevPortalContext.ts

@@ -1,164 +0,0 @@
-import { QueryClient } from "@tanstack/react-query";
-import { type ReactNode } from "react";
-import { create } from "zustand";
-import { type DevPortalPath, type DevPortalProps } from "../DevPortal.js";
-import { type AuthProvider } from "../authentication/authentication.js";
-import {
-  isApiKeyPlugin,
-  isNavigationPlugin,
-  needsInitialization,
-  type DevPortalPlugin,
-  type NavigationPlugin,
-} from "./plugins.js";
-
-import type { LucideIcon } from "lucide-react";
-import type { IconName } from "../components/DynamicIcon.js";
-
-export interface ApiIdentity {
-  authorizeRequest: (request: Request) => Request;
-  name: string;
-  id: string;
-}
-
-type BaseNavigationCategoryItem = {
-  label: ReactNode;
-  title?: string;
-  icon?: ReactNode | IconName;
-};
-
-export type PathNavigationCategoryItem = BaseNavigationCategoryItem & {
-  path: string;
-  children?: NavigationCategoryItem[];
-};
-
-export type HrefNavigationCategoryItem = BaseNavigationCategoryItem & {
-  href: string;
-};
-
-export type NavigationCategoryItem =
-  | PathNavigationCategoryItem
-  | HrefNavigationCategoryItem;
-
-export type NavigationCategory = {
-  label: string;
-  path?: string;
-  expanded?: boolean;
-  collapsible?: boolean;
-  icon?: LucideIcon;
-  children: NavigationCategoryItem[];
-};
-
-export type NavigationItem = {
-  label: string;
-  path: DevPortalPath;
-  categories?: NavigationCategory[];
-};
-
-export type SessionProfileState = {
-  isLoggedIn: boolean;
-  sub?: string;
-  email?: string;
-  name?: string;
-  email_verified?: string;
-  picture?: string;
-};
-
-export type RoutingState = {
-  path?: string;
-};
-
-export const queryClient = new QueryClient();
-
-export const useDevPortalState = create<SessionProfileState & RoutingState>(
-  () => ({
-    isLoggedIn: false,
-  }),
-);
-
-export type ApiKeyCache = "api-keys";
-export type DevPortalCacheKey = ApiKeyCache | string;
-
-export class DevPortalContext {
-  private plugins: DevPortalPlugin[] = [];
-  private navigationPlugins: NavigationPlugin[];
-
-  public navigation: NavigationItem[];
-  public meta: DevPortalProps["meta"];
-  public authentication?: AuthProvider;
-  public state: typeof useDevPortalState;
-
-  constructor(private config: DevPortalProps) {
-    this.plugins = config.plugins ?? [];
-    this.navigation = config.navigation;
-    this.navigationPlugins = this.plugins.filter(isNavigationPlugin);
-    this.authentication = config.authentication;
-    this.meta = config.meta;
-    this.state = useDevPortalState;
-  }
-
-  initialize = async () => {
-    this.plugins
-      .filter(needsInitialization)
-      .forEach((plugin) => plugin.initialize(this));
-    this.authentication?.initialize(this);
-  };
-
-  setUserProfile = async (profile: Partial<SessionProfileState>) => {
-    return useDevPortalState.setState(profile);
-  };
-
-  invalidateCache = async (key: DevPortalCacheKey[]) => {
-    queryClient.invalidateQueries({ queryKey: key });
-  };
-
-  getApiIdentities = async () => {
-    const keys = await Promise.all(
-      this.plugins
-        .filter(isApiKeyPlugin)
-        .map((plugin) => plugin.getIdentities(this)),
-    );
-
-    return keys.flat();
-  };
-
-  login = async () => {
-    if (!this.authentication) {
-      throw new Error("No authentication configured");
-    }
-
-    return this.authentication.login(this);
-  };
-
-  logout = async () => {
-    if (!this.authentication) {
-      throw new Error("No authentication configured");
-    }
-
-    return this.authentication.signOut(this);
-  };
-
-  handleAuthenticationResponse = async (path: {
-    pathname: string;
-    search: string;
-    hash: string;
-  }) => {
-    this.config.authentication?.handleAuthenticationResponse?.(path, this);
-  };
-
-  getNavigation = async (path: string) => {
-    const navigations = await Promise.all(
-      this.navigationPlugins.map(async (plugin) =>
-        plugin.getNavigation?.(path),
-      ),
-    );
-
-    return navigations.flatMap((nav) => nav ?? []);
-  };
-
-  sessionStorage = {
-    get: async (key: string) => localStorage.getItem(`session-${key}`) ?? "",
-    setProfile: async () => {},
-    set: async (key: string, value: string) =>
-      localStorage.setItem(`session-${key}`, value),
-  };
-}

package/src/app/core/helmet.ts

@@ -1,5 +0,0 @@
-import * as helmet from "react-helmet-async";
-
-export const Helmet = helmet.Helmet;
-export const HelmetData = helmet.HelmetData;
-export const HelmetProvider = helmet.HelmetProvider;

package/src/app/core/icons.tsx

@@ -1 +0,0 @@
-export * from "lucide-react";

package/src/app/core/plugins.ts

@@ -1,43 +0,0 @@
-import { type RouteObject } from "react-router-dom";
-import {
-  DevPortalContext,
-  type ApiIdentity,
-  type NavigationCategory,
-} from "./DevPortalContext.js";
-import { type Combine } from "./types/combine.js";
-
-export type PluginNavigationCategory = {
-  path: string;
-} & NavigationCategory;
-
-export type DevPortalPlugin = Combine<
-  [NavigationPlugin, ApiIdentityPlugin, InitializationPlugin]
->;
-
-export interface NavigationPlugin {
-  getRoutes: () => RouteObject[];
-  getNavigation?: (path: string) => Promise<PluginNavigationCategory[]>;
-}
-
-export interface ApiIdentityPlugin {
-  getIdentities: (context: DevPortalContext) => Promise<ApiIdentity[]>;
-}
-
-export interface InitializationPlugin {
-  initialize: (context: DevPortalContext) => Promise<void> | void;
-}
-
-export const isNavigationPlugin = (
-  obj: DevPortalPlugin,
-): obj is NavigationPlugin =>
-  "getRoutes" in obj && typeof obj.getRoutes === "function";
-
-export const needsInitialization = (
-  obj: DevPortalPlugin,
-): obj is InitializationPlugin =>
-  "initialize" in obj && typeof obj.initialize === "function";
-
-export const isApiKeyPlugin = (
-  obj: DevPortalPlugin,
-): obj is ApiIdentityPlugin =>
-  "getIdentities" in obj && typeof obj.getIdentities === "function";

package/src/app/core/router.tsx

@@ -1 +0,0 @@
-export * from "react-router-dom";

package/src/app/core/types/combine.ts

@@ -1,16 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
-  k: infer I,
-) => void
-  ? I
-  : never;
-
-type AnyCombination<T, U = T> = T extends any
-  ? U extends any
-    ? T | (T & U)
-    : never
-  : never;
-
-export type Combine<T extends any[]> =
-  | UnionToIntersection<T[number]>
-  | AnyCombination<T[number]>;

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

@@ -1,422 +0,0 @@
-/* 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) => {
-  return slugify(
-    (tag ? tag + "-" : "") +
-      (operation.summary ??
-        operation.operationId ??
-        `${operation.method}-${operation.path}`),
-    { lower: true, trim: true },
-  );
-};
-
-const cache = new LRUCache<string, 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,
-        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) =>
-        getAllOperations(ctx.schema.paths, parent.name).filter((item) =>
-          parent.name
-            ? item.tags?.includes(parent.name)
-            : !item.tags || item.tags.length === 0,
-        ),
-    }),
-  }),
-});
-
-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,
-            ...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 }),
-      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 = await 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/app/oas/graphql/server.ts

@@ -1,10 +0,0 @@
-import { createServer } from "node:http";
-import { createGraphQLServer } from "./index.js";
-
-const yoga = createGraphQLServer();
-
-const server = createServer(yoga);
-
-server.listen(4000, () => {
-  console.log(`🚀 Server ready at  http://localhost:4000/graphql`);
-});