@o1-labs/mina-archive-node-graphql 0.0.6

package/src/resolvers.ts

@@ -0,0 +1,102 @@
+import { makeExecutableSchema } from '@graphql-tools/schema';
+import { Resolvers } from './resolvers-types.js';
+import { visit, print, parse } from 'graphql';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import {
+  TracingState,
+  setSpanNameFromGraphQLContext,
+} from './tracing/tracer.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const schemaPath = path.resolve(__dirname, '../../schema.graphql');
+
+const fullResolvers: Resolvers = {
+  Query: {
+    events: async (_, { input }, context) => {
+      const graphQLSpan = setSpanNameFromGraphQLContext(
+        context,
+        'events.graphql'
+      );
+      return context.db_client.getEvents(input, {
+        tracingState: new TracingState(graphQLSpan),
+      });
+    },
+    actions: async (_, { input }, context) => {
+      const graphQLSpan = setSpanNameFromGraphQLContext(
+        context,
+        'actions.graphql'
+      );
+      return context.db_client.getActions(input, {
+        tracingState: new TracingState(graphQLSpan),
+      });
+    },
+    networkState: async (_, __, context) => {
+      const graphQLSpan = setSpanNameFromGraphQLContext(
+        context,
+        'networkState.graphql'
+      );
+      return context.db_client.getNetworkState({
+        tracingState: new TracingState(graphQLSpan),
+      });
+    },
+    blocks: async (_, { query, limit, sortBy }, context) => {
+      const graphQLSpan = setSpanNameFromGraphQLContext(
+        context,
+        'blocks.graphql'
+      );
+      return context.db_client.getBlocks(query, limit, sortBy, {
+        tracingState: new TracingState(graphQLSpan),
+      });
+    },
+  },
+};
+
+let resolvers: Resolvers = fullResolvers;
+let typeDefs: string | undefined = undefined;
+
+// If the ENABLED_QUERIES environment variable is set, filter the schema and resolvers.
+if (process.env.ENABLED_QUERIES !== undefined) {
+  const enabledQueries = process.env.ENABLED_QUERIES.split(',').map((q) =>
+    q.trim()
+  );
+
+  // If the list is not empty, filter the resolvers.
+  if (enabledQueries.length > 0) {
+    resolvers = {
+      Query: Object.fromEntries(
+        Object.entries(fullResolvers.Query || {}).filter(([queryName]) =>
+          enabledQueries.includes(queryName)
+        )
+      ),
+    };
+
+    // Filter the schema AST.
+    const typeDefsString = fs.readFileSync(schemaPath, 'utf-8');
+    const typeDefsAst = parse(typeDefsString);
+    const modifiedAst = visit(typeDefsAst, {
+      ObjectTypeDefinition(node) {
+        if (node.name.value === 'Query') {
+          return {
+            ...node,
+            fields: node.fields?.filter((field) =>
+              enabledQueries.includes(field.name.value)
+            ),
+          };
+        }
+        return node;
+      },
+    });
+    typeDefs = print(modifiedAst);
+  }
+}
+
+// Create the executable schema.
+const schema = makeExecutableSchema({
+  resolvers: [resolvers],
+  typeDefs: typeDefs || fs.readFileSync(schemaPath, 'utf-8'),
+});
+
+export { resolvers, schema };

package/src/server/plugins.ts

@@ -0,0 +1,56 @@
+import { useLogger } from '@envelop/core';
+import { useGraphQlJit } from '@envelop/graphql-jit';
+import { useDisableIntrospection } from '@envelop/disable-introspection';
+import { useOpenTelemetry } from '@envelop/opentelemetry';
+import { inspect } from 'node:util';
+
+import { initJaegerProvider } from '../tracing/jaeger-tracing.js';
+
+export { buildPlugins };
+
+async function buildPlugins() {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const plugins: any[] = [];
+  plugins.push(useGraphQlJit());
+
+  if (process.env.ENABLE_LOGGING) {
+    const provider = await initJaegerProvider();
+    plugins.push(
+      useOpenTelemetry(
+        {
+          resolvers: true, // Tracks resolvers calls, and tracks resolvers thrown errors
+          variables: true, // Includes the operation variables values as part of the metadata collected
+          result: true, // Includes execution result object as part of the metadata collected
+        },
+        provider
+      )
+    );
+  }
+
+  if (!process.env.ENABLE_INTROSPECTION) {
+    plugins.push(useDisableIntrospection());
+  }
+
+  plugins.push(
+    useLogger({
+      logFn: (eventName, args) => {
+        if (args?.result?.errors) {
+          console.debug(
+            eventName,
+            inspect(args.args.contextValue.params, {
+              showHidden: false,
+              depth: null,
+              colors: true,
+            }),
+            inspect(args.result.errors, {
+              showHidden: false,
+              depth: null,
+              colors: true,
+            })
+          );
+        }
+      },
+    })
+  );
+  return plugins;
+}

package/src/server/server.ts

@@ -0,0 +1,30 @@
+import { createYoga, LogLevel } from 'graphql-yoga';
+import { createServer } from 'http';
+import { Plugin } from '@envelop/core';
+import { schema } from '../resolvers.js';
+import type { GraphQLContext } from '../context.js';
+
+export { BLOCK_RANGE_SIZE, ENABLE_BLOCK_TRANSACTION_DETAILS, buildServer };
+
+const LOG_LEVEL = (process.env.LOG_LEVEL as LogLevel) || 'info';
+const BLOCK_RANGE_SIZE = Number(process.env.BLOCK_RANGE_SIZE) || 10000;
+const ENABLE_BLOCK_TRANSACTION_DETAILS =
+  process.env.ENABLE_BLOCK_TRANSACTION_DETAILS === 'true';
+
+function buildServer(context: GraphQLContext, plugins: Plugin[]) {
+  const yoga = createYoga<GraphQLContext>({
+    schema,
+    logging: LOG_LEVEL,
+    graphqlEndpoint: '/',
+    landingPage: false,
+    healthCheckEndpoint: '/healthcheck',
+    graphiql: process.env.ENABLE_GRAPHIQL === 'true' ? true : false,
+    plugins,
+    cors: {
+      origin: process.env.CORS_ORIGIN ?? '*',
+      methods: ['GET', 'POST'],
+    },
+    context,
+  });
+  return createServer(yoga);
+}

package/src/services/actions-service/actions-service.interface.ts

@@ -0,0 +1,9 @@
+import { Actions } from '../../blockchain/types.js';
+import { ActionFilterOptionsInput } from '../../resolvers-types.js';
+
+export interface IActionsService {
+  getActions(
+    input: ActionFilterOptionsInput,
+    options: unknown
+  ): Promise<Actions>;
+}

package/src/services/actions-service/actions-service.ts

@@ -0,0 +1,195 @@
+import type postgres from 'postgres';
+
+import {
+  BlockStatusFilter,
+  BlocksWithTransactionsMap,
+  FieldElementIdWithValueMap,
+  Action,
+  Actions,
+} from '../../blockchain/types.js';
+import type { ActionFilterOptionsInput } from '../../resolvers-types.js';
+import { DEFAULT_TOKEN_ID } from '../../blockchain/constants.js';
+import { createBlockInfo } from '../../blockchain/utils.js';
+import {
+  getActionsQuery,
+  checkActionState,
+} from '../../db/sql/events-actions/queries.js';
+import {
+  partitionBlocks,
+  getElementIdFieldValues,
+  mapActionOrEvent,
+  removeRedundantEmittedFields,
+  sortAndFilterBlocks,
+} from '../data-adapters/database-row-adapters.js';
+import { IActionsService } from './actions-service.interface.js';
+import {
+  TracingState,
+  extractTraceStateFromOptions,
+} from '../../tracing/tracer.js';
+import {
+  throwActionStateError,
+  throwBlockRangeError,
+} from '../../errors/error.js';
+import { BLOCK_RANGE_SIZE } from '../../server/server.js';
+
+export { ActionsService };
+
+class ActionsService implements IActionsService {
+  private readonly client: postgres.Sql;
+
+  constructor(client: postgres.Sql) {
+    this.client = client;
+  }
+
+  async getActions(
+    input: ActionFilterOptionsInput,
+    options: unknown
+  ): Promise<Actions> {
+    const tracingState = extractTraceStateFromOptions(options);
+    return (await this.getActionData(input, { tracingState })) ?? [];
+  }
+
+  async getActionData(
+    input: ActionFilterOptionsInput,
+    { tracingState }: { tracingState: TracingState }
+  ): Promise<Actions> {
+    const sqlSpan = tracingState.startSpan('actions.SQL');
+    const rows = await this.executeActionsQuery(input);
+
+    sqlSpan.end();
+
+    const processingSpan = tracingState.startSpan('actions.processing');
+    const elementIdFieldValues = getElementIdFieldValues(rows);
+    const blocksWithTransactions = partitionBlocks(rows);
+    const actionsData = this.blocksToActions(
+      blocksWithTransactions,
+      elementIdFieldValues
+    );
+    sortAndFilterBlocks(actionsData);
+    processingSpan.end();
+    return actionsData;
+  }
+
+  async executeActionsQuery(input: ActionFilterOptionsInput) {
+    const { address, to, from, endActionState, fromActionState } = input;
+
+    // Check if action states exist.
+    if (fromActionState) {
+      const fromActionStateExists = await checkActionState(
+        this.client,
+        fromActionState
+      );
+      if (!fromActionStateExists || !fromActionStateExists.length) {
+        throwActionStateError(
+          `fromActionState ${fromActionState} does not exist`
+        );
+      }
+    }
+    if (endActionState) {
+      const endActionStateExists = await checkActionState(
+        this.client,
+        endActionState
+      );
+      if (!endActionStateExists || !endActionStateExists.length) {
+        throwActionStateError(
+          `endActionState ${endActionState} does not exist`
+        );
+      }
+    }
+    let { tokenId, status } = input;
+
+    tokenId ||= DEFAULT_TOKEN_ID;
+    status ||= BlockStatusFilter.all;
+    if (to && from && to < from) {
+      throwBlockRangeError('to must be greater than from');
+    }
+    if (to && from && to - from > BLOCK_RANGE_SIZE) {
+      throwBlockRangeError(
+        `The block range is too large. The maximum range is ${BLOCK_RANGE_SIZE}`
+      );
+    }
+
+    return getActionsQuery(
+      this.client,
+      address,
+      tokenId,
+      status,
+      to?.toString(),
+      from?.toString(),
+      fromActionState?.toString(),
+      endActionState?.toString()
+    );
+  }
+
+  blocksToActions(
+    blocksWithTransactions: BlocksWithTransactionsMap,
+    elementIdFieldValues: FieldElementIdWithValueMap
+  ) {
+    const actions: Actions = [];
+    const blockTransactionEntries = Array.from(
+      blocksWithTransactions.entries()
+    );
+    for (let i = 0; i < blockTransactionEntries.length; i++) {
+      const transactions = blockTransactionEntries[i][1];
+      const transaction = transactions.values().next().value![0];
+      const blockInfo = createBlockInfo(transaction);
+      const {
+        action_state_value1,
+        action_state_value2,
+        action_state_value3,
+        action_state_value4,
+        action_state_value5,
+      } = transaction;
+
+      const actionsData: Action[][] = [];
+      for (const [, transaction] of transactions) {
+        const filteredBlocks = removeRedundantEmittedFields(transaction);
+        const actionData = mapActionOrEvent(
+          'action',
+          filteredBlocks,
+          elementIdFieldValues
+        ) as Action[];
+        actionsData.push(actionData);
+      }
+      actions.push({
+        blockInfo,
+        actionData: this.sortActions(actionsData.flat()),
+        actionState: {
+          /* eslint-disable */
+          actionStateOne: action_state_value1!,
+          actionStateTwo: action_state_value2!,
+          actionStateThree: action_state_value3!,
+          actionStateFour: action_state_value4!,
+          actionStateFive: action_state_value5!,
+          /* eslint-enable */
+        },
+      });
+    }
+    return actions;
+  }
+
+  sortActions(actions: Action[]): Action[] {
+    return actions.sort((a, b) => {
+      // Sort by sequence number
+      if (
+        a.transactionInfo.sequenceNumber !== b.transactionInfo.sequenceNumber
+      ) {
+        return (
+          a.transactionInfo.sequenceNumber - b.transactionInfo.sequenceNumber
+        );
+      }
+
+      // Sort by account update index within the transaction
+      const aAccountUpdateIndex =
+        a.transactionInfo.zkappAccountUpdateIds.indexOf(
+          Number(a.accountUpdateId)
+        );
+      const bAccountUpdateIndex =
+        b.transactionInfo.zkappAccountUpdateIds.indexOf(
+          Number(b.accountUpdateId)
+        );
+
+      return aAccountUpdateIndex - bAccountUpdateIndex;
+    });
+  }
+}

package/src/services/blocks-service/blocks-service.interface.ts

@@ -0,0 +1,11 @@
+import { Blocks } from '../../blockchain/types.js';
+import { BlockQueryInput, BlockSortByInput } from '../../resolvers-types.js';
+
+export interface IBlocksService {
+  getBlocks(
+    query: BlockQueryInput | null | undefined,
+    limit: number | null | undefined,
+    sortBy: BlockSortByInput | null | undefined,
+    options: unknown
+  ): Promise<Blocks>;
+}