@codex-data/sdk 0.6.2 → 1.0.0-rc2

package/src/scripts/buildSdk.ts

@@ -0,0 +1,173 @@
+import fs from "fs";
+import camelCase from "lodash/camelCase";
+import path from "path";
+
+const GENERATED_SUBSCRIPTIONS_DIRECTORY = path.join(
+  __dirname,
+  "..",
+  "resources",
+  "generated_subscriptions",
+);
+const GENERATED_MUTATIONS_DIRECTORY = path.join(
+  __dirname,
+  "..",
+  "resources",
+  "generated_mutations",
+);
+const GENERATED_QUERIES_DIRECTORY = path.join(
+  __dirname,
+  "..",
+  "resources",
+  "generated_queries",
+);
+
+class Subscription {
+  constructor(private subscriptionName: string) {}
+  pre() {
+    return `${this.subscriptionName}SubscriptionVariables, ${this.subscriptionName}Subscription`;
+  }
+  main() {
+    const graphqlString = fs.readFileSync(
+      path.join(
+        GENERATED_SUBSCRIPTIONS_DIRECTORY,
+        this.subscriptionName + ".graphql",
+      ),
+      "utf8",
+    );
+    return `${camelCase(this.subscriptionName)} = async (vars: ${
+      this.subscriptionName
+    }SubscriptionVariables, sink: Sink<ExecutionResult<${
+      this.subscriptionName
+    }Subscription>>) => this.sdk.subscribe(\`${graphqlString}\`, vars, sink);`;
+  }
+}
+
+class Mutation {
+  constructor(private mutationName: string) {}
+  pre() {
+    return `${this.mutationName}Document,
+  ${this.mutationName}MutationVariables`;
+  }
+  main() {
+    return `${camelCase(this.mutationName)} = async (vars: ${
+      this.mutationName
+    }MutationVariables) => this.sdk.mutation(${
+      this.mutationName
+    }Document, vars);`;
+  }
+}
+
+class Query {
+  constructor(private queryName: string) {}
+
+  pre() {
+    return `${this.queryName}Document,
+  ${this.queryName}QueryVariables`;
+  }
+
+  main() {
+    return `${camelCase(this.queryName)} = async (vars: ${
+      this.queryName
+    }QueryVariables) => this.sdk.query(${this.queryName}Document, vars);`;
+  }
+}
+
+class SDK {
+  private queries: Query[] = [];
+  private mutations: Mutation[] = [];
+  private subscriptions: Subscription[] = [];
+
+  constructor() {
+    this.initialize();
+  }
+
+  initialize() {
+    // crawl the generatedQueries and then create the typescript code for that query.
+    const queries = fs.readdirSync(GENERATED_QUERIES_DIRECTORY);
+    const mutations = fs.readdirSync(GENERATED_MUTATIONS_DIRECTORY);
+    const subscriptions = fs.readdirSync(GENERATED_SUBSCRIPTIONS_DIRECTORY);
+
+    for (const file of queries) {
+      this.queries.push(new Query(path.basename(file, ".graphql")));
+    }
+    for (const file of mutations) {
+      this.mutations.push(new Mutation(path.basename(file, ".graphql")));
+    }
+    for (const file of subscriptions) {
+      this.subscriptions.push(
+        new Subscription(path.basename(file, ".graphql")),
+      );
+    }
+  }
+
+  printSubscriptions(): string {
+    return `
+// THIS FILE IS AUTOMATICALLY GENERATED, DO NOT EDIT IT DIRECTLY
+import {
+${this.subscriptions.map((q) => "  " + q.pre()).join(",\n")}
+} from "./generated/graphql";
+import { Codex } from "./index";
+import { ExecutionResult, Sink } from "graphql-ws";
+
+export class Subscribe {
+  constructor(private sdk: Codex) {}
+  ${this.subscriptions.map((q) => q.main()).join("\n")}
+}
+    `;
+  }
+
+  printMutations(): string {
+    return `
+// THIS FILE IS AUTOMATICALLY GENERATED, DO NOT EDIT IT DIRECTLY
+import {
+${this.mutations.map((q) => "  " + q.pre()).join(",\n")}
+} from "./generated/graphql";
+      import { Codex } from "./index";
+
+      export class Mutation {
+        constructor(private sdk: Codex) {}
+        ${this.mutations.map((q) => q.main()).join("\n")}
+      }
+    `;
+  }
+
+  printQueries(): string {
+    return `
+// THIS FILE IS AUTOMATICALLY GENERATED, DO NOT EDIT IT DIRECTLY
+import {
+${this.queries.map((q) => "  " + q.pre()).join(",\n")}
+} from "./generated/graphql";
+      import { Codex } from "./index";
+
+      export class Query {
+        constructor(private sdk: Codex) {}
+        ${this.queries.map((q) => q.main()).join("\n")}
+      }
+    `;
+  }
+
+  output() {
+    fs.writeFileSync(
+      path.join(__dirname, "..", "sdk", "Subscribe.ts"),
+      this.printSubscriptions(),
+      "utf8",
+    );
+    fs.writeFileSync(
+      path.join(__dirname, "..", "sdk", "Mutation.ts"),
+      this.printMutations(),
+      "utf8",
+    );
+    fs.writeFileSync(
+      path.join(__dirname, "..", "sdk", "Query.ts"),
+      this.printQueries(),
+      "utf8",
+    );
+  }
+}
+
+async function run() {
+  const sdk = new SDK();
+  sdk.output();
+}
+
+run().then(() => process.exit());

package/src/scripts/generateGraphql.ts

@@ -0,0 +1,236 @@
+import fs from "fs";
+import * as gql from "gql-query-builder";
+import VariableOptions from "gql-query-builder/build/VariableOptions";
+import { mkdirp } from "mkdirp";
+import path from "path";
+
+type SchemaTypeDefinition = {
+  kind:
+    | "NON_NULL"
+    | "SCALAR"
+    | "LIST"
+    | "OBJECT"
+    | "INPUT_OBJECT"
+    | "ENUM"
+    | "UNION"
+    | undefined
+    | null;
+  name?: string | null;
+  ofType?: SchemaTypeDefinition | null;
+  isDeprecated?: boolean | null;
+};
+
+type SchemaType = {
+  name: string;
+  description?: string | null;
+  type: SchemaTypeDefinition;
+  isDeprecated?: boolean | null;
+  fields?: SchemaType[];
+};
+
+type Fields = Array<string | { [key: string]: Fields }>;
+
+function capitalize(str: string) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+export const getLeafType = (
+  type: SchemaTypeDefinition,
+  allTypes: SchemaType[],
+  result: Fields,
+  currentName: string,
+  level = 0,
+): Fields => {
+  if (level > 8 || !type?.kind || type.kind === "UNION" || type.isDeprecated)
+    return result;
+
+  // If it's a scalar, return the name
+  if (type.kind === "SCALAR" || type.kind === "ENUM")
+    return [...result, currentName!];
+
+  // If it's an object resolve it.
+  if (type.kind === "OBJECT") {
+    // For each of the fields of the subtype, resolve them
+    const subType = allTypes.find((t) => t.name === type.name);
+    const subTypeLeaves = (subType?.fields ?? [])
+      .filter((t) => !t.isDeprecated)
+      .map((f: SchemaType) =>
+        getLeafType(f.type, allTypes, [], f.name, level + 1),
+      )
+      .flat();
+    return [
+      ...result,
+      ...(level === 0 ? subTypeLeaves : [{ [currentName]: subTypeLeaves }]),
+    ];
+  }
+
+  // If it's a list, resolve the first object type
+  if (type.kind === "LIST")
+    return getLeafType(type.ofType!, allTypes, [...result], currentName, level);
+
+  // If it's required, resolve the first object type
+  if (type.kind === "NON_NULL")
+    return getLeafType(type.ofType!, allTypes, [...result], currentName, level);
+
+  throw new Error(`Unknown type ${type.name} ${type.kind}`);
+};
+
+export const getLeafArgs = (
+  type: SchemaTypeDefinition,
+  result: VariableOptions,
+): VariableOptions => {
+  if (
+    type.kind === "NON_NULL" &&
+    ["INPUT_OBJECT", "SCALAR", "OBJECT", "ENUM"].includes(
+      type.ofType?.kind as string,
+    )
+  )
+    return { ...result, type: `${type.ofType!.name!}!` };
+
+  // If it's a scalar, return the name
+  if (
+    type.kind === "SCALAR" ||
+    type.kind === "OBJECT" ||
+    type.kind === "ENUM" ||
+    type.kind === "INPUT_OBJECT"
+  )
+    return { ...result, type: type.name!, value: null };
+
+  // If it's a list, resolve the first object type
+  if (type.kind === "LIST")
+    return getLeafArgs(type.ofType!, { ...result, list: true });
+
+  // If it's required, resolve the first object type
+  if (type.kind === "NON_NULL")
+    return getLeafArgs(type.ofType!, { ...result, required: true });
+
+  throw new Error(`Unknown type ${type.name} ${type.kind}`);
+};
+
+export function parseVariables(args: SchemaType[]) {
+  const parsedVariables = args.reduce(
+    (acc: VariableOptions, arg: SchemaType) => {
+      return {
+        ...acc,
+        [arg.name]: getLeafArgs(arg.type, {}),
+      };
+    },
+    {},
+  );
+  return parsedVariables;
+}
+
+/**
+ * Runs a query against the currently published graphql schema,
+ * and generates a query ts file for query.
+ */
+async function run() {
+  console.log("Generating...");
+
+  // Fetch schema from remote
+  const res = await fetch(`https://graph.codex.io/schema/latest.json`, {
+    method: "GET",
+  });
+  const schemaJson = await res.json();
+
+  const types = schemaJson.__schema.types;
+  const mutationType = types.find(
+    (type: SchemaType) => type.name === "Mutation",
+  );
+  const queryType = types.find((type: SchemaType) => type.name === "Query");
+  const subscriptionType = types.find(
+    (type: SchemaType) => type.name === "Subscription",
+  );
+
+  for (const field of mutationType.fields) {
+    const args = field.args;
+    const parsedVariables = parseVariables(args);
+    const parsedFields = getLeafType(field.type, types, [], "").filter(Boolean);
+
+    const mutationBuilderObject = gql.mutation({
+      operation: field.name,
+      variables: Object.keys(parsedVariables).length
+        ? parsedVariables
+        : undefined,
+      fields: parsedFields.length ? parsedFields : undefined,
+    });
+    console.log(`Writing mutation: ${field.name}.graphql`);
+    const mutationsFolderPath = path.join(
+      __dirname,
+      "..",
+      "resources",
+      "generated_mutations",
+    );
+    await mkdirp(mutationsFolderPath);
+    fs.writeFileSync(
+      path.join(mutationsFolderPath, `${capitalize(field.name)}.graphql`),
+      `mutation ${capitalize(field.name)}${mutationBuilderObject.query
+        .toString()
+        .slice("mutation ".length)}`,
+    );
+  }
+
+  for (const field of subscriptionType.fields) {
+    const args = field.args;
+    const parsedVariables = parseVariables(args);
+    const parsedFields = getLeafType(field.type, types, [], "").filter(Boolean);
+
+    const subscriptionBuilderObject = gql.subscription({
+      operation: field.name,
+      variables: Object.keys(parsedVariables).length
+        ? parsedVariables
+        : undefined,
+      fields: parsedFields.length ? parsedFields : undefined,
+    });
+    console.log(`Writing subscription: ${field.name}.graphql`);
+    const subscriptionsFolderPath = path.join(
+      __dirname,
+      "..",
+      "resources",
+      "generated_subscriptions",
+    );
+    await mkdirp(subscriptionsFolderPath);
+    fs.writeFileSync(
+      path.join(subscriptionsFolderPath, `${capitalize(field.name)}.graphql`),
+      `subscription ${capitalize(field.name)}${subscriptionBuilderObject.query
+        .toString()
+        .slice("subscription ".length)}`,
+    );
+  }
+
+  for (const field of queryType.fields) {
+    if (field.isDeprecated) {
+      console.log("Skipping deprecated field", field.name);
+      continue;
+    }
+
+    const args = field.args;
+    const parsedVariables = parseVariables(args);
+    const parsedFields = getLeafType(field.type, types, [], "").filter(Boolean);
+
+    const queryBuilderObject = gql.query({
+      operation: field.name,
+      variables: Object.keys(parsedVariables).length
+        ? parsedVariables
+        : undefined,
+      fields: parsedFields.length ? parsedFields : undefined,
+    });
+    console.log(`Writing query: ${field.name}.graphql`);
+
+    const queriesFolderPath = path.join(
+      __dirname,
+      "..",
+      "resources",
+      "generated_queries",
+    );
+    await mkdirp(queriesFolderPath);
+    fs.writeFileSync(
+      path.join(queriesFolderPath, `${capitalize(field.name)}.graphql`),
+      `query ${capitalize(field.name)}${queryBuilderObject.query
+        .toString()
+        .slice("query ".length)}`,
+    );
+  }
+}
+
+run().then(() => process.exit());

package/src/sdk/Mutation.ts

@@ -1,15 +1,24 @@
-import { DeleteWebhooksInput } from "../resources/graphql";
+// THIS FILE IS AUTOMATICALLY GENERATED, DO NOT EDIT IT DIRECTLY
 import {
+  CreateApiTokensDocument,
+  CreateApiTokensMutationVariables,
   CreateWebhooksDocument,
-  CreateWebhooksInput,
+  CreateWebhooksMutationVariables,
+  DeleteApiTokenDocument,
+  DeleteApiTokenMutationVariables,
   DeleteWebhooksDocument,
+  DeleteWebhooksMutationVariables,
 } from "./generated/graphql";
 import { Codex } from "./index";
 
 export class Mutation {
   constructor(private sdk: Codex) {}
-  createWebhooks = async (vars: { input: CreateWebhooksInput }) =>
+  deleteApiToken = async (vars: DeleteApiTokenMutationVariables) =>
+    this.sdk.mutation(DeleteApiTokenDocument, vars);
+  createWebhooks = async (vars: CreateWebhooksMutationVariables) =>
     this.sdk.mutation(CreateWebhooksDocument, vars);
-  deleteWebhooks = async (vars: { input: DeleteWebhooksInput }) =>
+  createApiTokens = async (vars: CreateApiTokensMutationVariables) =>
+    this.sdk.mutation(CreateApiTokensDocument, vars);
+  deleteWebhooks = async (vars: DeleteWebhooksMutationVariables) =>
     this.sdk.mutation(DeleteWebhooksDocument, vars);
 }