rollback to js generated file approach

authdog · Dec 18, 2023 · 2e72f12 · 2e72f12
1 parent baebe71
commit 2e72f12
Show file tree

Hide file tree

Showing 6 changed files with 155 additions and 138 deletions.
diff --git a/.changeset/mighty-candles-count.md b/.changeset/mighty-candles-count.md
@@ -0,0 +1,6 @@
+---
+"@authdog/hydra-core": patch
+"@authdog/hydra-cli": patch
+---
+
+cleanup, rollback to local js file generated
diff --git a/packages/cli/src/utils/introspectSchemas.ts b/packages/cli/src/utils/introspectSchemas.ts
@@ -1,7 +1,9 @@
 import fetch from "node-fetch";
 import { getIntrospectionQuery, buildClientSchema, printSchema } from "graphql";
 import { initSpinner, stopSpinner } from "./spinners";
-import { spawn } from "node:child_process";
+// import { spawn } from "node:child_process";
+import fs from "fs";
+
 
 export async function introspectRemoteSchema(endpointUrl: string) {
   try {
@@ -75,21 +77,26 @@ export const buildSchemaIntrospection = async (
     introspected: s.introspected
   }));
 
-  if (namespaceId && namespaceId !== "test") {
-  // write with wrangler child process
-  // wrangler kv:key put schema '{"foo": "bar"}' --namespace-id=c63f48a0f29843e8ab8251ef533e1c9c
-  const wrangler = spawn("wrangler", [
-    "kv:key",
-    "put",
-    "schema",
-    JSON.stringify(fileContent),
-    `--namespace-id=${namespaceId}`,
-  ]);
-
-  wrangler.stdout.on("data", (data) => {
-    console.log(`stdout: ${data}`);
-  });
-  }
+
+  // generate a schemaRaw file (.hydra/schemaRaw.js) module.exports = <fileContent>
+  fs.writeFileSync(outputPath, `module.exports = ${JSON.stringify(fileContent, null, 2)}`);
+
+
+  // if (namespaceId && namespaceId !== "test") {
+  // // write with wrangler child process
+  // // wrangler kv:key put schema '{"foo": "bar"}' --namespace-id=c63f48a0f29843e8ab8251ef533e1c9c
+  // const wrangler = spawn("wrangler", [
+  //   "kv:key",
+  //   "put",
+  //   "schema",
+  //   JSON.stringify(fileContent),
+  //   `--namespace-id=${namespaceId}`,
+  // ]);
+
+  // wrangler.stdout.on("data", (data) => {
+  //   console.log(`stdout: ${data}`);
+  // });
+  // }
 
 
 };
diff --git a/packages/core/src/handlers/graphql.ts b/packages/core/src/handlers/graphql.ts
@@ -1,14 +1,15 @@
 import { createYoga } from "graphql-yoga";
 // TODO: add create schema method to build dynamically the schema and persist to KV
-import { schema } from "../schema";
+import { getSchema } from "../schema";
 
 export const GraphQLHandler = async (
   req: Request,
   env: any,
   ctx: any,
 ): Promise<any> => {
+  const {rawSchema} = ctx;
   const yoga = createYoga({
-    schema,
+    schema: await getSchema(rawSchema),
     context: async (event) => {
       const { request } = event;
       const authorization =

diff --git a/packages/core/src/schema.ts b/packages/core/src/schema.ts
@@ -1,34 +1,124 @@
 import { makeExecutableSchema } from "@graphql-tools/schema";
 import { default as fetch } from "node-fetch";
+import {
+  addTypenameKeywordToSchema,
+  buildGraphQLSchemaSDL,
+  unifyGraphQLSchemasObjects,
+} from "./schemaUtils";
 
 let schemas = [];
 
+// extract everything between type Query {}
+const queryRegex = /type Query {([\s\S]*?)}/;
+const mutationRegex = /type Mutation {([\s\S]*?)}/;
 
-try {
-  // schemaRaw = require(".hydra/schemaRaw");
-  const filePath = "./.hydra/schemaRaw.json";
-  const fileContent = {} // TODO sync with kv
-  // schemas = JSON.parse(fileContent);
+const extractPrimitiveWithRegExp = (rawSchema: string, regex: RegExp) => {
+  const primitiveMatch = rawSchema.match(regex);
+  const primitiveBody = primitiveMatch?.[1];
+  const primitiveBodyTrimmed = primitiveBody?.trim();
+  const primitiveBodyTrimmedLines = primitiveBodyTrimmed?.split("\n");
+  const operations = primitiveBodyTrimmedLines?.map((line) => {
+    const lineTrimmed = line.trim();
+    const lineTrimmedWords = lineTrimmed.split(" ");
+    let operationName = lineTrimmedWords?.[0];
+    // remove everything after : or ( (inclusive) in mutationName
+    // health: -> health
+    // health(meta: SomeInput) -> health
+    operationName = operationName?.replace(/[:\(].*$/, "");
+    return {
+      operationName,
+    };
+  });
+  return operations;
+};
 
-  console.log("schemas", schemas);
 
-} catch (error) {
-  // Handle error when import fails
-  console.error("Error loading schemaRaw:", error);
-}
+export const getSchema = (schemas: any) => {
+
+  // If the schemaRaw is empty, handle it here
+  if (!schemas || schemas.length === 0) {
+    console.warn("SchemaRaw is empty or invalid.");
+    // Perform necessary actions or log messages for an empty schemaRaw
+  }
+
+
+  const queries = [
+    ...schemas
+      .map(({ introspected, url }) => {
+        return extractPrimitiveWithRegExp(introspected, queryRegex).map(
+          ({ operationName }) => {
+            return {
+              id: operationName,
+              resolver: async (_, __, ctx) => {
+                const queryBody = ctx?.params?.query;
+                const variables = ctx?.params?.variables;
+                const authorization = getAuthorizationFromContext(ctx);
+                return await fetchGraphQLEndpoint(
+                  url,
+                  addTypenameKeywordToSchema(queryBody),
+                  variables,
+                  operationName,
+                  { Authorization: authorization },
+                );
+              },
+            };
+          },
+        );
+      })
+      .flat(),
+  ];
+
+  const mutations = [
+    ...schemas
+      .map(({ introspected, url }) => {
+        return extractPrimitiveWithRegExp(introspected, mutationRegex).map(
+          ({ operationName }) => {
+            return {
+              id: operationName,
+              resolver: async (_, bindings, ctx) => {
+                const queryBody = ctx?.params?.query;
+                const variables = ctx?.params?.variables;
+                const authorization = getAuthorizationFromContext(ctx);
+                return await fetchGraphQLEndpoint(
+                  url,
+                  addTypenameKeywordToSchema(queryBody),
+                  variables,
+                  operationName,
+                  { Authorization: authorization },
+                );
+              },
+            };
+          },
+        );
+      })
+      .flat(),
+  ];
+
+  const resolvers = {
+    Query: {},
+    Mutation: {},
+  };
+
+  queries?.forEach(({ id, resolver }) => {
+    resolvers.Query[id] = resolver;
+  });
+
+  mutations?.forEach(({ id, resolver }) => {
+    resolvers.Mutation[id] = resolver;
+  });
+
+  let schema = makeExecutableSchema({
+    typeDefs: buildGraphQLSchemaSDL(
+      unifyGraphQLSchemasObjects([
+        ...schemas.map(({ introspected }) => introspected),
+      ]),
+    ),
+    resolvers,
+  });
 
-// If the schemaRaw is empty, handle it here
-if (!schemas || schemas.length === 0) {
-  console.warn("SchemaRaw is empty or invalid.");
-  // Perform necessary actions or log messages for an empty schemaRaw
+  return schema;
 }
 
-import {
-  addTypenameKeywordToSchema,
-  buildGraphQLSchemaSDL,
-  unifyGraphQLSchemasObjects,
-} from "./schemaUtils";
-
 const fetchGraphQLEndpoint = async (
   endpoint: string,
   query: string,
@@ -67,107 +157,13 @@ const fetchGraphQLEndpoint = async (
   }
 };
 
-// extract everything between type Query {}
-const queryRegex = /type Query {([\s\S]*?)}/;
-const mutationRegex = /type Mutation {([\s\S]*?)}/;
-
-const extractPrimitiveWithRegExp = (rawSchema: string, regex: RegExp) => {
-  const primitiveMatch = rawSchema.match(regex);
-  const primitiveBody = primitiveMatch?.[1];
-  const primitiveBodyTrimmed = primitiveBody?.trim();
-  const primitiveBodyTrimmedLines = primitiveBodyTrimmed?.split("\n");
-  const operations = primitiveBodyTrimmedLines?.map((line) => {
-    const lineTrimmed = line.trim();
-    const lineTrimmedWords = lineTrimmed.split(" ");
-    let operationName = lineTrimmedWords?.[0];
-    // remove everything after : or ( (inclusive) in mutationName
-    // health: -> health
-    // health(meta: SomeInput) -> health
-    operationName = operationName?.replace(/[:\(].*$/, "");
-    return {
-      operationName,
-    };
-  });
-  return operations;
-};
-
 const getAuthorizationFromContext = (ctx) => {
   const authorization = ctx?.request?.headers?.get("authorization");
   return authorization;
 };
 
-const queries = [
-  ...schemas
-    .map(({ introspected, url }) => {
-      return extractPrimitiveWithRegExp(introspected, queryRegex).map(
-        ({ operationName }) => {
-          return {
-            id: operationName,
-            resolver: async (_, __, ctx) => {
-              const queryBody = ctx?.params?.query;
-              const variables = ctx?.params?.variables;
-              const authorization = getAuthorizationFromContext(ctx);
-              return await fetchGraphQLEndpoint(
-                url,
-                addTypenameKeywordToSchema(queryBody),
-                variables,
-                operationName,
-                { Authorization: authorization },
-              );
-            },
-          };
-        },
-      );
-    })
-    .flat(),
-];
-
-const mutations = [
-  ...schemas
-    .map(({ introspected, url }) => {
-      return extractPrimitiveWithRegExp(introspected, mutationRegex).map(
-        ({ operationName }) => {
-          return {
-            id: operationName,
-            resolver: async (_, bindings, ctx) => {
-              const queryBody = ctx?.params?.query;
-              const variables = ctx?.params?.variables;
-              const authorization = getAuthorizationFromContext(ctx);
-              return await fetchGraphQLEndpoint(
-                url,
-                addTypenameKeywordToSchema(queryBody),
-                variables,
-                operationName,
-                { Authorization: authorization },
-              );
-            },
-          };
-        },
-      );
-    })
-    .flat(),
-];
-
-const resolvers = {
-  Query: {},
-  Mutation: {},
-};
 
-queries?.forEach(({ id, resolver }) => {
-  resolvers.Query[id] = resolver;
-});
 
-mutations?.forEach(({ id, resolver }) => {
-  resolvers.Mutation[id] = resolver;
-});
 
-let schema = makeExecutableSchema({
-  typeDefs: buildGraphQLSchemaSDL(
-    unifyGraphQLSchemasObjects([
-      ...schemas.map(({ introspected }) => introspected),
-    ]),
-  ),
-  resolvers,
-});
 
-export { schema };
+// export { schema };
diff --git a/services/itty-hydra/main.ts b/services/itty-hydra/main.ts
@@ -3,9 +3,11 @@ import { createCors } from "itty-cors";
 // import { withDurables } from "itty-durable";
 import { NotFound } from "./handlers/notFound";
 import { Health } from "./handlers/health";
-// import { GraphQLHandler, HydraHandler } from "@authdog/hydra-core";
+import { GraphQLHandler, HydraHandler } from "@authdog/hydra-core";
 import { HydraConfigAcme } from "./hydra.config";
 
+import {default as rawSchema} from "./.hydra/schemaRaw"
+
 const { preflight, corsify } = createCors();
 
 
@@ -17,7 +19,9 @@ router
   .get("/health", Health)
   .get("/schema", async (req, env, ctx) => {
 
-    const schema = await ctx.kv.get("schema")
+    const schema = await ctx.rawSchema
+
+    // const schema = await ctx.kv.get("schema")
 
     return new Response(
       JSON.stringify(schema),
@@ -29,17 +33,20 @@ router
 
   })
   // serves playground
-  // .get("/graphql", GraphQLHandler)
-  // .post("/graphql", HydraHandler)
+  .get("/graphql", GraphQLHandler)
+  .post("/graphql", HydraHandler)
   .get("*", NotFound);
 
 const handleRequest = (req, env, ctx) => {
   const { HYDRA_ACME } = env;
 
+  console.log("rawSchema", rawSchema);
+
   const enrichedContext = {
     ...ctx,
     kv: HYDRA_ACME,
     hydraConfig: HydraConfigAcme,
+    rawSchema
     // rateLimiter: null,
   };
 

diff --git a/services/itty-hydra/package.json b/services/itty-hydra/package.json
@@ -6,7 +6,7 @@
   "private": true,
   "scripts": {
     "build": "node build.mjs",
-    "dev": "npx wrangler dev  -c wrangler.base.toml --live-reload --port 3565",
+    "dev": "npx wrangler dev  -c wrangler.base.toml --live-reload --port 3566",
     "deploy": "npx wrangler -c wrangler.base.toml deploy --minify"
   },
   "keywords": [],