Wip: add types to revisionData in node builder

erhathaway · erhathaway · commit b39afda4ace2 · 2019-10-22T16:22:31.000-07:00
diff --git a/dev/resolvers/query.ts b/dev/resolvers/query.ts
@@ -58,19 +58,23 @@ const query: {
             .where({id: args.id})
             .first()) as {id: string; name: string};
 
-        return await versionConnection<QueryTeamResolver>(currentNode, [parent, args, ctx, info], {
-            knex: ctx.sqlClient,
-            // nodeBuilder,
-            nodeBuilder: (previousNode, versionInfo: IAllNodeBuilderVersionInfo<number>) => {
-                if (typeGuards.isNodeBuilderNodeChangeVersionInfo(versionInfo)) {
-                    const a = versionInfo.revisionData;
-                    return {...previousNode, ...a};
-                }
-                return previousNode;
-            },
-            nodeId: args.id,
-            nodeName: 'team'
-        });
+        return await versionConnection<QueryTeamResolver, {id: 'hi'}>(
+            currentNode,
+            [parent, args, ctx, info],
+            {
+                knex: ctx.sqlClient,
+                // nodeBuilder,
+                nodeBuilder: (previousNode, versionInfo) => {
+                    if (typeGuards.isNodeBuilderNodeChangeVersionInfo(versionInfo)) {
+                        const a = versionInfo.revisionData;
+                        return {...previousNode, ...a};
+                    }
+                    return previousNode;
+                },
+                nodeId: args.id,
+                nodeName: 'team'
+            }
+        );
     },
     async todoList(parent, args, ctx, info) {
         const currentNode = await ctx.sqlClient
diff --git a/src/data_accessors/sql/query_time_range_of_version_connection.ts b/src/data_accessors/sql/query_time_range_of_version_connection.ts
@@ -6,19 +6,25 @@ import {
     ITableAndColumnNames,
     IVersionConnectionInfo,
     NodeInConnection,
-    ILoggerConfig
+    ILoggerConfig,
+    IVersionConnection,
+    ExtractNodeFromVersionConnection,
+    UnPromisify
 } from '../../types';
 import {castDateToUTCSeconds, unixSecondsToSqlTimestamp} from '../../lib/time';
 import {getLoggerFromConfig} from '../../logger';
 /**
  * Fetch the number of full node snapshots for the node id and node schema version
  * If a snapshot exists within the expected snapshot frequency, then we don't need to take another snapshot
  */
-export default async <ResolverT extends (...args: [any, any, any, any]) => any>(
+export default async <
+    ResolverT extends (...args: [any, any, any, any]) => Promise<IVersionConnection<any>>,
+    Snapshot = ExtractNodeFromVersionConnection<UnPromisify<ReturnType<ResolverT>>>
+>(
     knex: Knex,
     tableAndColumnNames: ITableAndColumnNames,
     resolverArgs: Parameters<ResolverT>,
-    nodesInVersionConnection: NodeInConnection[],
+    nodesInVersionConnection: Array<NodeInConnection<Snapshot>>,
     allNodeInstancesInConnection: Array<
         Pick<IVersionConnectionInfo<ResolverT>, 'nodeId' | 'nodeName'>
     >,
@@ -66,7 +72,7 @@ export default async <ResolverT extends (...args: [any, any, any, any]) => any>(
     // Filter out any nodes that have snapshots
     const oldestNodes = (oldestNodesWithPossibilityOfSnapshots
         ? oldestNodesWithPossibilityOfSnapshots.filter(node => node && node.snapshot == null) // tslint:disable-line
-        : []) as NodeInConnection[] | undefined;
+        : []) as Array<NodeInConnection<Snapshot>> | undefined;
 
     logger.debug(
         'Number of node types that dont have snapshots in initial connection',
@@ -85,7 +91,7 @@ export default async <ResolverT extends (...args: [any, any, any, any]) => any>(
         };
     }
     // Determine the oldest version with a full node snapshot
-    const oldestCreatedAt = await getMinCreatedAtOfVersionWithSnapshot(
+    const oldestCreatedAt = await getMinCreatedAtOfVersionWithSnapshot<Snapshot>(
         knex,
         tableAndColumnNames,
         oldestNodes,
@@ -115,10 +121,10 @@ export default async <ResolverT extends (...args: [any, any, any, any]) => any>(
  * Gets the closest revision with a snapshot to the oldest revision of interest
  * This will be the initial snapshot that full nodes are calculated off of
  */
-const getMinCreatedAtOfVersionWithSnapshot = async (
+const getMinCreatedAtOfVersionWithSnapshot = async <Snapshot>(
     knex: Knex,
     {table_names, event, node_snapshot}: ITableAndColumnNames,
-    oldestNodes: NodeInConnection[],
+    oldestNodes: Array<NodeInConnection<Snapshot>>,
     logger?: ILoggerConfig['logger']
 ): Promise<number | undefined> => {
     logger && logger.debug('Querying oldest snapshots for nodes:', oldestNodes); // tslint:disable-line
diff --git a/src/data_accessors/sql/query_version_connection.ts b/src/data_accessors/sql/query_version_connection.ts
@@ -12,7 +12,10 @@ import {
     IGqlVersionNode,
     IVersionConnectionInfo,
     NodeInConnection,
-    ILoggerConfig
+    ILoggerConfig,
+    ExtractNodeFromVersionConnection,
+    UnPromisify,
+    IVersionConnection
 } from '../../types';
 import {unixSecondsToSqlTimestamp, castDateToUTCSeconds} from '../../lib/time';
 import {getLoggerFromConfig} from '../../logger';
@@ -47,7 +50,9 @@ const castNodeWithRevisionTimeInDateTimeToUnixSecs = (logger?: ILoggerConfig['lo
     };
 };
 
-type NodesInConnectionUnprocessed = Array<NodeInConnection & {roleName: string}>;
+type NodesInConnectionUnprocessed<Snapshot> = Array<
+    NodeInConnection<Snapshot> & {roleName: string}
+>;
 
 const nodeTransformer = (logger?: ILoggerConfig['logger']) => {
     const firstTransformer = castNodeWithRevisionTimeInDateTimeToUnixSecs(logger);
@@ -65,7 +70,10 @@ const nodeTransformer = (logger?: ILoggerConfig['logger']) => {
     };
 };
 
-export default async <ResolverT extends (...args: any[]) => any>(
+export default async <
+    ResolverT extends (...args: any[]) => Promise<IVersionConnection<any>>,
+    Snapshot = ExtractNodeFromVersionConnection<UnPromisify<ReturnType<ResolverT>>>
+>(
     connectionInputs: IInputArgs,
     knex: Knex,
     {
@@ -83,7 +91,13 @@ export default async <ResolverT extends (...args: any[]) => any>(
     loggerConfig?: ILoggerConfig
 ): //  INamesForTablesAndColumns,
 // extractors: IVersionConnectionExtractors<ResolverT>
-Promise<IQueryResult<NodeInConnection & {snapshot?: string}>> => {
+Promise<
+    IQueryResult<
+        NodeInConnection<Snapshot> & {
+            snapshot?: Snapshot;
+        }
+    >
+> => {
     const parentLogger = getLoggerFromConfig(loggerConfig);
     const logger = parentLogger.child({query: 'Version connection'});
 
@@ -210,8 +224,8 @@ Promise<IQueryResult<NodeInConnection & {snapshot?: string}>> => {
         .orderBy(`main.id`, 'desc');
 
     logger.debug('Raw SQL:', logger.level === 'debug' && query.toQuery());
-    const nodeResult = (await query) as NodesInConnectionUnprocessed;
-    const uniqueVersions = aggregateVersionsById(nodeResult);
+    const nodeResult = (await query) as NodesInConnectionUnprocessed<Snapshot>;
+    const uniqueVersions = aggregateVersionsById<Snapshot>(nodeResult);
     nodeConnection.addResult(uniqueVersions);
     const {pageInfo, edges} = nodeConnection;
     return {pageInfo, edges};
@@ -222,8 +236,8 @@ Promise<IQueryResult<NodeInConnection & {snapshot?: string}>> => {
  * for each user role. Thus, we need to combine user roles together into an array for
  * each duplicate of a revision.
  */
-const aggregateVersionsById = (
-    nodeVersions: NodesInConnectionUnprocessed,
+const aggregateVersionsById = <Snapshot>(
+    nodeVersions: NodesInConnectionUnprocessed<Snapshot>,
     _logger?: ILoggerConfig['logger']
 ) => {
     // extract all the user roles for the version
@@ -259,7 +273,7 @@ const aggregateVersionsById = (
             return uniqueVersions;
         },
         {} as {
-            [id: string]: NodeInConnection;
+            [id: string]: NodeInConnection<Snapshot>;
         }
     );
 
diff --git a/src/type_guards.ts b/src/type_guards.ts
@@ -38,34 +38,36 @@ export const isGqlNodeChangeNode = (
     return (n as IGqlVersionNodeChangeNode).revisionData !== undefined;
 };
 
-export const isNodeBuilderNodeVersionInfoWithSnapshot = (
+export const isNodeBuilderNodeVersionInfoWithSnapshot = <A, B, C>(
     n:
-        | IAllNodeBuilderVersionInfo
-        | Required<INodeBuilderNodeChangeVersionInfo>
-        | Required<INodeBuilderNodeFragmentChangeVersionInfo>
+        | IAllNodeBuilderVersionInfo<A, B, C>
+        | Required<INodeBuilderNodeChangeVersionInfo<A, B, C>>
+        | Required<INodeBuilderNodeFragmentChangeVersionInfo<A, B, C>>
 ): n is
-    | Required<INodeBuilderNodeChangeVersionInfo>
-    | Required<INodeBuilderNodeFragmentChangeVersionInfo> => {
+    | Required<INodeBuilderNodeChangeVersionInfo<A, B, C>>
+    | Required<INodeBuilderNodeFragmentChangeVersionInfo<A, B, C>> => {
     return (
         (n as
-            | Required<INodeBuilderNodeChangeVersionInfo>
-            | Required<INodeBuilderNodeFragmentChangeVersionInfo>).snapshot != null // tslint:disable-line
+            | Required<INodeBuilderNodeChangeVersionInfo<A, B, C>>
+            | Required<INodeBuilderNodeFragmentChangeVersionInfo<A, B, C>>).snapshot != null // tslint:disable-line
     );
 };
 
-export const isNodeBuilderNodeChangeVersionInfo = (
-    n: IAllNodeBuilderVersionInfo | INodeBuilderNodeChangeVersionInfo
-): n is INodeBuilderNodeChangeVersionInfo => {
+export const isNodeBuilderNodeChangeVersionInfo = <A, B, C>(
+    n: IAllNodeBuilderVersionInfo<A, B, C> | INodeBuilderNodeChangeVersionInfo<A, B, C>
+): n is INodeBuilderNodeChangeVersionInfo<A, B, C> => {
     return (
-        (n as INodeBuilderNodeChangeVersionInfo).revisionData !== undefined &&
-        (n as INodeBuilderNodeFragmentChangeVersionInfo).childRevisionData === undefined
+        (n as INodeBuilderNodeChangeVersionInfo<A, B, C>).revisionData !== undefined &&
+        (n as INodeBuilderNodeFragmentChangeVersionInfo<A, B, C>).childRevisionData === undefined
     );
 };
 
-export const isNodeBuilderNodeFragmentChangeVersionInfo = (
-    n: IAllNodeBuilderVersionInfo | INodeBuilderNodeFragmentChangeVersionInfo
-): n is INodeBuilderNodeFragmentChangeVersionInfo => {
-    return (n as INodeBuilderNodeFragmentChangeVersionInfo).childRevisionData !== undefined;
+export const isNodeBuilderNodeFragmentChangeVersionInfo = <A, B, C>(
+    n: IAllNodeBuilderVersionInfo<A, B, C> | INodeBuilderNodeFragmentChangeVersionInfo<A, B, C>
+): n is INodeBuilderNodeFragmentChangeVersionInfo<A, B, C> => {
+    return (
+        (n as INodeBuilderNodeFragmentChangeVersionInfo<A, B, C>).childRevisionData !== undefined
+    );
 };
 
 export const shouldSkipNodeBuilderBecauseHasLinkChangeVersionInfo = (
diff --git a/src/types.ts b/src/types.ts
@@ -147,7 +147,7 @@ export type IGqlVersionNode =
     | IGqlVersionNodeFragmentChangeNode
     | IGqlVersionLinkChangeNode;
 
-export type NodeInConnection = IGqlVersionNode & {snapshot?: string};
+export type NodeInConnection<Snapshot> = IGqlVersionNode & {snapshot?: Snapshot};
 
 export interface IVersionConnection<Node> {
     edges: Array<{
@@ -169,17 +169,19 @@ export interface IVersionConnection<Node> {
  *
  */
 
-type ExtractNodeFromVersionConnection<P> = P extends IVersionConnection<infer T> ? T : never;
+export type ExtractNodeFromVersionConnection<P> = P extends IVersionConnection<infer T> ? T : never;
 
 export interface IVersionConnectionInfo<
-    Resolver extends (...args: any[]) => Promise<IVersionConnection<any>>
+    Resolver extends (...args: any[]) => Promise<IVersionConnection<any>>,
+    RevisionData = any,
+    FragmentNode = any
 > {
     nodeId: string | number;
     nodeName: string;
     nodeBuilder: <
-        GqlNode = ExtractNodeFromVersionConnection<UnPromisify<ReturnType<Resolver>>>,
-        RevisionData = any,
-        FragmentNode extends object = object
+        GqlNode = ExtractNodeFromVersionConnection<UnPromisify<ReturnType<Resolver>>>
+        // RevisionData = any,
+        // FragmentNode = any
     >(
         previousNode: GqlNode,
         versionInfo: IAllNodeBuilderVersionInfo<number, RevisionData>,
@@ -188,12 +190,14 @@ export interface IVersionConnectionInfo<
     ) => GqlNode;
 }
 export interface IVersionConnectionExtractors<
-    Resolver extends (...args: any[]) => Promise<IVersionConnection<any>>
+    Resolver extends (...args: any[]) => Promise<IVersionConnection<any>>,
+    RevisionData = any,
+    FragmentNode = any
 > extends IVersionConnectionInfo<Resolver> {
     knex: Knex;
     nodeId: IVersionConnectionInfo<Resolver>['nodeId'];
     nodeName: IVersionConnectionInfo<Resolver>['nodeName'];
-    nodeBuilder: IVersionConnectionInfo<Resolver>['nodeBuilder'];
+    nodeBuilder: IVersionConnectionInfo<Resolver, RevisionData, FragmentNode>['nodeBuilder'];
 }
 
 export interface IVersionRecorderExtractors<
@@ -335,9 +339,9 @@ export interface IPersistVersionInfo {
 
 export type PersistVersion = (versionInfo: IPersistVersionInfo) => Promise<void>;
 
-export type IAllNodeBuilderVersionInfo<CreatedAt = number, RevisionData = any> =
-    | INodeBuilderNodeChangeVersionInfo<CreatedAt, RevisionData>
-    | INodeBuilderNodeFragmentChangeVersionInfo<CreatedAt, RevisionData>;
+export type IAllNodeBuilderVersionInfo<CreatedAt = number, Snapshot = any, RevisionData = any> =
+    | INodeBuilderNodeChangeVersionInfo<CreatedAt, Snapshot, RevisionData>
+    | INodeBuilderNodeFragmentChangeVersionInfo<CreatedAt, Snapshot, RevisionData>;
 
 export interface INodeBuilderVersionInfo<CreatedAt = number> {
     type: string;
@@ -350,8 +354,11 @@ export interface INodeBuilderVersionInfo<CreatedAt = number> {
     resolverOperation: string;
 }
 
-export interface INodeBuilderNodeChangeVersionInfo<CreatedAt = number, RevisionData = any>
-    extends INodeBuilderVersionInfo<CreatedAt> {
+export interface INodeBuilderNodeChangeVersionInfo<
+    CreatedAt = number,
+    Snapshot = any,
+    RevisionData = any
+> extends INodeBuilderVersionInfo<CreatedAt> {
     type: string;
 
     id: number;
@@ -364,11 +371,14 @@ export interface INodeBuilderNodeChangeVersionInfo<CreatedAt = number, RevisionD
     revisionData: RevisionData;
     nodeSchemaVersion: string;
 
-    snapshot?: string;
+    snapshot?: Snapshot;
 }
 
-export interface INodeBuilderNodeFragmentChangeVersionInfo<CreatedAt = number, RevisionData = any>
-    extends INodeBuilderVersionInfo<CreatedAt> {
+export interface INodeBuilderNodeFragmentChangeVersionInfo<
+    CreatedAt = number,
+    Snapshot = any,
+    RevisionData = any
+> extends INodeBuilderVersionInfo<CreatedAt> {
     type: string;
 
     id: number;
@@ -384,7 +394,7 @@ export interface INodeBuilderNodeFragmentChangeVersionInfo<CreatedAt = number, R
     childRevisionData: RevisionData;
     childNodeSchemaVersion: string;
 
-    snapshot?: string;
+    snapshot?: Snapshot;
 }
 
 export type QueryShouldTakeNodeSnapshot = (eventInfo: IEventNodeChangeInfo) => Promise<boolean>;
diff --git a/src/version_connection/build_connection.ts b/src/version_connection/build_connection.ts
@@ -1,12 +1,27 @@
 import {isGqlNodeChangeNode} from 'type_guards';
 import {EVENT_IMPLEMENTOR_TYPE_NAMES} from 'enums';
 import {getLoggerFromConfig} from 'logger';
-import {ILoggerConfig, UnPromisify, NodeInConnection, IVersionConnection} from 'types';
+import {
+    ILoggerConfig,
+    UnPromisify,
+    NodeInConnection,
+    IVersionConnection,
+    ExtractNodeFromVersionConnection
+} from 'types';
 import {IQueryResult} from '@social-native/snpkg-snapi-connections';
 
-export default <ResolverT extends (...args: [any, any, any, any]) => IVersionConnection<any>>(
-    versionNodeConnection: IQueryResult<NodeInConnection & {snapshot?: string}>,
-    nodesOfConnectionByEventId: {[eventId: string]: UnPromisify<ReturnType<ResolverT>>},
+export default <
+    ResolverT extends (...args: [any, any, any, any]) => Promise<IVersionConnection<any>>,
+    Snapshot = ExtractNodeFromVersionConnection<UnPromisify<ReturnType<ResolverT>>>
+>(
+    versionNodeConnection: IQueryResult<
+        NodeInConnection<Snapshot> & {
+            snapshot?: Snapshot;
+        }
+    >,
+    nodesOfConnectionByEventId: {
+        [eventId: string]: Snapshot;
+    },
     originNodeInstance: {nodeName: string; nodeId: string | number},
     loggerConfig?: ILoggerConfig
 ) => {
diff --git a/src/version_connection/build_nodes.ts b/src/version_connection/build_nodes.ts
diff --git a/src/version_connection/index.ts b/src/version_connection/index.ts
