9429574795

Committed 08 Jun 2024 02:55PM UTC coverage: 31.975% (+0.1%) from 31.88%

Build # 9429574795

Build Type

Pull #9384

github

Committed by

oetherington

Commit Message

Fix postgres bootstrap

Pull Request Pull Request #9384: [EA] Vibes check

Run Details

4825 of 39374 branches covered (12.25%)

Branch coverage included in aggregate %.

177 of 337 new or added lines in 35 files covered. (52.52%)

291 existing lines in 9 files now uncovered.

28140 of 63722 relevant lines covered (44.16%)

181.79 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

84.77

/packages/lesswrong/server/sql/SqlFragment.ts

import { getCollectionByTypeName } from "@/lib/vulcan-lib/getCollection";
import ProjectionContext, { CustomResolver, PrefixGenerator } from "./ProjectionContext";
import FragmentLexer from "./FragmentLexer";
import merge from "lodash/merge";

type SqlFragmentArg = {
  inName: string,
  outName: string,
}

/**
 * `SqlFragmentField` specifies a single named field in a GraphQL fragment
 */
type SqlFragmentField = {
  type: "field",
  name: string,
  args: SqlFragmentArg[],
}

/**
 * `SqlFragmentPick` specifies a sub-object in a fragment that contains further
 * fields "picked" from another fragment
 */
type SqlFragmentPick = {
  type: "pick",
  name: string,
  args: SqlFragmentArg[],
  entries: SqlFragmentEntryMap,
}

type SqlFragmentEntry = SqlFragmentField | SqlFragmentPick;

type SqlFragmentEntryMap = Record<string, SqlFragmentEntry>;

const getResolverCollection = (
  resolver: CustomResolver,
): CollectionBase<CollectionNameString> => {
  if (typeof resolver.type !== "string") {
    throw new Error(`Resolver "${resolver.fieldName}" has a scalar type`);
  }
  let type = resolver.type;
  const exclam = type.indexOf("!");
  if (exclam >= 0) {
    type = type.substring(0, exclam);
  }
  while (type[0] === "[") {
    type = type.substring(1, type.length - 1);
  }
  return getCollectionByTypeName(type);
}

/**
 * `SqlFragment` contains the logic for parsing GraphQL fragments into a
 * form that can be efficiently converted into SQL projections. As this is
 * relatively expensive, each fragment is parsed only once when it is first
 * requested and the value is then memoized globally (see `fragments.ts`).
 *
 * The man external interface here is the `buildProjection` method that
 * generates a `ProjectionContext` corresponding to a specific query with
 * specific arguments.
 */
class SqlFragment {
  private lexer: FragmentLexer;
  private parsedEntries: SqlFragmentEntryMap | undefined;

  constructor(
    /** The raw source text of the fragment */
    fragmentSrc: string,
    /**
     * A function that takes a fragment name and returns the registered SQL
     * fragment. This is taken as an argument to avoid an import cycle (DI to
     * the rescue).
     */
    private getFragment: (name: FragmentName) => SqlFragment | null,
  ) {
    this.lexer = new FragmentLexer(fragmentSrc);
  }

  /**
   * The name of this fragment (eg; PostsMinimumInfo).
   */
  getName(): string {
    return this.lexer.getName();
  }

  /**
   * The GraphQL type that this fragment is defined on (eg; Post).
   */
  getBaseTypeName(): string {
    return this.lexer.getBaseTypeName();
  }

  private parseArgs(argsString = ""): SqlFragmentArg[] {
    const args: SqlFragmentArg[] = [];
    const matches = argsString.matchAll(/([a-zA-Z0-9_]+)\s*:\s*\$([a-zA-Z0-9_]+)/g);
    for (const match of matches) {
      args.push({
        inName: match[2],
        outName: match[1],
      });
    }
    return args;
  }

  private parseEntries(): SqlFragmentEntryMap {
    let entries: SqlFragmentEntryMap = {};
    let line: string | null;
    while ((line = this.lexer.next())) {
      if (line === "}") {
        break;
      }

      let match = line.match(/^([a-zA-Z0-9-_]+)(\(.*\))?$/);
      if (match?.[0]) {
        const name = match[1];
        const args = match[2];
        entries[name] = {
          type: "field",
          name,
          args: this.parseArgs(args),
        };
        continue;
      }

      match = line.match(/^\.\.\.([a-zA-Z0-9-_]+)$/)
      if (match?.[1]) {
        // `getFragment` takes a `FragmentName` but then checks if it's valid.
        // It should probably just be typed as taking a string but that might
        // not a be a totally safe change, so for now we'll just cast.
        const fragmentName = match[1] as FragmentName;
        const fragment = this.getFragment(fragmentName);
        if (!fragment) {
          throw new Error(`Fragment "${fragmentName}" not found`);
        }
        const fragmentEntries = fragment.getParsedEntries();
        entries = merge(entries, fragmentEntries);
        continue;
      }

      match = line.match(/^([a-zA-Z0-9-_]+)(\(.*\))?\s*{$/);
      if (match?.[1]) {
        const name = match[1];
        const args = match[2];
        entries[name] = merge(entries[name], {
          type: "pick",
          name,
          args: this.parseArgs(args),
          entries: this.parseEntries(),
        });
        continue;
      }

      throw new Error(`Parse error in fragment "${this.getName()}": "${line}"`);
    }
    return entries;
  }

  getParsedEntries(): SqlFragmentEntryMap {
    if (!this.parsedEntries) {
      this.parsedEntries = this.parseEntries();
    }
    return this.parsedEntries;
  }

  private compileFieldEntry(
    context: ProjectionContext,
    {name}: SqlFragmentField,
  ) {
    const resolver = context.getResolver(name);
    if (name === "__typename") {
      // Skip - this is a fake field for Apollo's use
    } else if (resolver) {
      if (resolver.sqlResolver) {
        const result = resolver.sqlResolver(context.getSqlResolverArgs());
        context.addProjection(name, result);
      } else {
        context.addCodeResolver(resolver.fieldName ?? name, resolver.resolver);
      }
    } else if (context.getSchema()[name]) {
      // Do nothing - this is a native DB field and will get selected by the
      // default * selector
    } else {
      const baseTypeName = this.getBaseTypeName();
      throw new Error(`Field "${name}" doesn't exist on "${baseTypeName}"`);
    }
  }

  private compilePickEntry(
    context: ProjectionContext,
    {name, entries}: SqlFragmentPick,
  ) {
    const resolver = context.getResolver(name);
    if (resolver) {
      if (resolver.sqlResolver) {
        const joinCountBefore = context.getJoins().length;
        const result = resolver.sqlResolver(context.getSqlResolverArgs());
        const joins = context.getJoins();
        const didJoin = joinCountBefore < joins.length;
        if (didJoin) {
          // We don't care about the resolver result here, just the side-effect of
          // registering the necessary join. Note that we assume that only one
          // join gets registered here - it's theoretically possible that this
          // assumption wouldn't be true, but only if you do some really-deep
          // hack that bypasses the entire vulcan schema/graphql setup.
          const collection = getResolverCollection(resolver);
          const aggregate = {
            prefix: joins[joins.length - 1].prefix,
            argOffset: context.getArgs().length,
          };
          const gen = context.getPrefixGenerator();
          const subcontext = new ProjectionContext(collection, aggregate, gen);
          this.compileEntries(subcontext, entries);
          context.aggregate(subcontext, name);
        } else {
          // If we don't add a join then just save the projection
          context.addProjection(name, result);
        }
      } else {
        context.addCodeResolver(resolver.fieldName ?? name, resolver.resolver);
      }
    } else {
      const baseTypeName = this.getBaseTypeName();
      throw new Error(`Field "${name}" on "${baseTypeName}" has no resolver`);
    }
  }

  private compileEntries(
    context: ProjectionContext,
    entries: SqlFragmentEntryMap,
  ) {
    if (!context.getIsAggregate()) {
      context.addProjection("*", undefined, false);
    }

    for (const entryName in entries) {
      const entry = entries[entryName];
      switch (entry.type) {
      case "field":
        this.compileFieldEntry(context, entry);
        break;
      case "pick":
        this.compilePickEntry(context, entry);
        break;
      }
    }
  }

  private compileProjection(context: ProjectionContext) {
    const entries = this.getParsedEntries();
    if (!this.lexer.isFinished()) {
      throw new Error(`Mismatched braces in fragment: "${this.getName()}"`);
    }
    this.compileEntries(context, entries);
  }

  buildProjection<N extends CollectionNameString = CollectionNameString>(
    currentUser: DbUser | UsersCurrent | null,
    resolverArgs?: Record<string, unknown> | null,
    prefixGenerator?: PrefixGenerator,
  ): ProjectionContext<N> {
    const baseTypeName = this.getBaseTypeName();
    const collection = getCollectionByTypeName(baseTypeName);
    const context = new ProjectionContext(collection, undefined, prefixGenerator);
    context.setCurrentUser(currentUser);
    context.addResolverArgs(resolverArgs ?? {});
    this.compileProjection(context);
    return context;
  }
}

export default SqlFragment;

1	import { getCollectionByTypeName } from "@/lib/vulcan-lib/getCollection";	5,290✔
2	import ProjectionContext, { CustomResolver, PrefixGenerator } from "./ProjectionContext";	43✔
3	import FragmentLexer from "./FragmentLexer";	43✔
4	import merge from "lodash/merge";	43✔
5
6	type SqlFragmentArg = {
7	inName: string,
8	outName: string,
9	}
10
11	/**
12	* `SqlFragmentField` specifies a single named field in a GraphQL fragment
13	*/
14	type SqlFragmentField = {
15	type: "field",
16	name: string,
17	args: SqlFragmentArg[],
18	}
19
20	/**
21	* `SqlFragmentPick` specifies a sub-object in a fragment that contains further
22	* fields "picked" from another fragment
23	*/
24	type SqlFragmentPick = {
25	type: "pick",
26	name: string,
27	args: SqlFragmentArg[],
28	entries: SqlFragmentEntryMap,
29	}
30
31	type SqlFragmentEntry = SqlFragmentField \| SqlFragmentPick;
32
33	type SqlFragmentEntryMap = Record<string, SqlFragmentEntry>;
34
35	const getResolverCollection = (	43✔
36	resolver: CustomResolver,
37	): CollectionBase<CollectionNameString> => {
38	if (typeof resolver.type !== "string") {	6!
39	throw new Error(`Resolver "${resolver.fieldName}" has a scalar type`);	×
40	}
41	let type = resolver.type;	6✔
42	const exclam = type.indexOf("!");	6✔
43	if (exclam >= 0) {	6!
44	type = type.substring(0, exclam);	×
45	}
46	while (type[0] === "[") {	6✔
NEW 47	type = type.substring(1, type.length - 1);	×
48	}
49	return getCollectionByTypeName(type);	6✔
50	}
51
52	/**
53	* `SqlFragment` contains the logic for parsing GraphQL fragments into a
54	* form that can be efficiently converted into SQL projections. As this is
55	* relatively expensive, each fragment is parsed only once when it is first
56	* requested and the value is then memoized globally (see `fragments.ts`).
57	*
58	* The man external interface here is the `buildProjection` method that
59	* generates a `ProjectionContext` corresponding to a specific query with
60	* specific arguments.
61	*/
62	class SqlFragment {
63	private lexer: FragmentLexer;
64	private parsedEntries: SqlFragmentEntryMap \| undefined;
65
66	constructor(
67	/** The raw source text of the fragment */
68	fragmentSrc: string,
69	/**
70	* A function that takes a fragment name and returns the registered SQL
71	* fragment. This is taken as an argument to avoid an import cycle (DI to
72	* the rescue).
73	*/
74	private getFragment: (name: FragmentName) => SqlFragment \| null,	5,161✔
75	) {
76	this.lexer = new FragmentLexer(fragmentSrc);	5,161✔
77	}
78
79	/**
80	* The name of this fragment (eg; PostsMinimumInfo).
81	*/
82	getName(): string {
83	return this.lexer.getName();	×
84	}
85
86	/**
87	* The GraphQL type that this fragment is defined on (eg; Post).
88	*/
89	getBaseTypeName(): string {
90	return this.lexer.getBaseTypeName();	4✔
91	}
92
93	private parseArgs(argsString = ""): SqlFragmentArg[] {	360✔
94	const args: SqlFragmentArg[] = [];	363✔
95	const matches = argsString.matchAll(/([a-zA-Z0-9_]+)\s:\s\$([a-zA-Z0-9_]+)/g);	363✔
96	for (const match of matches) {	363✔
97	args.push({	4✔
98	inName: match[2],
99	outName: match[1],
100	});
101	}
102	return args;	363✔
103	}
104
105	private parseEntries(): SqlFragmentEntryMap {
106	let entries: SqlFragmentEntryMap = {};	66✔
107	let line: string \| null;
108	while ((line = this.lexer.next())) {	66✔
109	if (line === "}") {	436✔
110	break;	41✔
111	}
112
113	let match = line.match(/^([a-zA-Z0-9-_]+)(\(.*\))?$/);	395✔
114	if (match?.[0]) {	395✔
115	const name = match[1];	322✔
116	const args = match[2];	322✔
117	entries[name] = {	322✔
118	type: "field",
119	name,
120	args: this.parseArgs(args),
121	};
122	continue;	322✔
123	}
124
125	match = line.match(/^\.\.\.([a-zA-Z0-9-_]+)$/)	73✔
126	if (match?.[1]) {	73✔
127	// `getFragment` takes a `FragmentName` but then checks if it's valid.
128	// It should probably just be typed as taking a string but that might
129	// not a be a totally safe change, so for now we'll just cast.
130	const fragmentName = match[1] as FragmentName;	32✔
131	const fragment = this.getFragment(fragmentName);	32✔
132	if (!fragment) {	32!
133	throw new Error(`Fragment "${fragmentName}" not found`);	×
134	}
135	const fragmentEntries = fragment.getParsedEntries();	32✔
136	entries = merge(entries, fragmentEntries);	32✔
137	continue;	32✔
138	}
139
140	match = line.match(/^([a-zA-Z0-9-_]+)(\(.\))?\s{$/);	41✔
141	if (match?.[1]) {	41!
142	const name = match[1];	41✔
143	const args = match[2];	41✔
144	entries[name] = merge(entries[name], {	41✔
145	type: "pick",
146	name,
147	args: this.parseArgs(args),
148	entries: this.parseEntries(),
149	});
150	continue;	41✔
151	}
152
153	throw new Error(`Parse error in fragment "${this.getName()}": "${line}"`);	×
154	}
155	return entries;	66✔
156	}
157
158	getParsedEntries(): SqlFragmentEntryMap {
159	if (!this.parsedEntries) {	40✔
160	this.parsedEntries = this.parseEntries();	25✔
161	}
162	return this.parsedEntries;	40✔
163	}
164
165	private compileFieldEntry(
166	context: ProjectionContext,
167	{name}: SqlFragmentField,
168	) {
169	const resolver = context.getResolver(name);	269✔
170	if (name === "__typename") {	269!
171	// Skip - this is a fake field for Apollo's use
172	} else if (resolver) {	269✔
173	if (resolver.sqlResolver) {	28✔
174	const result = resolver.sqlResolver(context.getSqlResolverArgs());	12✔
175	context.addProjection(name, result);	12✔
176	} else {
177	context.addCodeResolver(resolver.fieldName ?? name, resolver.resolver);	16!
178	}
179	} else if (context.getSchema()[name]) {	241!
180	// Do nothing - this is a native DB field and will get selected by the
181	// default * selector
182	} else {
183	const baseTypeName = this.getBaseTypeName();	×
184	throw new Error(`Field "${name}" doesn't exist on "${baseTypeName}"`);	×
185	}
186	}
187
188	private compilePickEntry(
189	context: ProjectionContext,
190	{name, entries}: SqlFragmentPick,
191	) {
192	const resolver = context.getResolver(name);	42✔
193	if (resolver) {	42!
194	if (resolver.sqlResolver) {	42✔
195	const joinCountBefore = context.getJoins().length;	6✔
196	const result = resolver.sqlResolver(context.getSqlResolverArgs());	6✔
197	const joins = context.getJoins();	6✔
198	const didJoin = joinCountBefore < joins.length;	6✔
199	if (didJoin) {	6!
200	// We don't care about the resolver result here, just the side-effect of
201	// registering the necessary join. Note that we assume that only one
202	// join gets registered here - it's theoretically possible that this
203	// assumption wouldn't be true, but only if you do some really-deep
204	// hack that bypasses the entire vulcan schema/graphql setup.
205	const collection = getResolverCollection(resolver);	6✔
206	const aggregate = {	6✔
207	prefix: joins[joins.length - 1].prefix,
208	argOffset: context.getArgs().length,
209	};
210	const gen = context.getPrefixGenerator();	6✔
211	const subcontext = new ProjectionContext(collection, aggregate, gen);	6✔
212	this.compileEntries(subcontext, entries);	6✔
213	context.aggregate(subcontext, name);	6✔
214	} else {
215	// If we don't add a join then just save the projection
NEW 216	context.addProjection(name, result);	×
217	}
218	} else {
219	context.addCodeResolver(resolver.fieldName ?? name, resolver.resolver);	36✔
220	}
221	} else {
222	const baseTypeName = this.getBaseTypeName();	×
223	throw new Error(`Field "${name}" on "${baseTypeName}" has no resolver`);	×
224	}
225	}
226
227	private compileEntries(
228	context: ProjectionContext,
229	entries: SqlFragmentEntryMap,
230	) {
231	if (!context.getIsAggregate()) {	10✔
232	context.addProjection("*", undefined, false);	4✔
233	}
234
235	for (const entryName in entries) {	10✔
236	const entry = entries[entryName];	311✔
237	switch (entry.type) {	311✔
238	case "field":
239	this.compileFieldEntry(context, entry);	269✔
240	break;	269✔
241	case "pick":
242	this.compilePickEntry(context, entry);	42✔
243	break;	42✔
244	}
245	}
246	}
247
248	private compileProjection(context: ProjectionContext) {
249	const entries = this.getParsedEntries();	4✔
250	if (!this.lexer.isFinished()) {	4!
251	throw new Error(`Mismatched braces in fragment: "${this.getName()}"`);	×
252	}
253	this.compileEntries(context, entries);	4✔
254	}
255
256	buildProjection<N extends CollectionNameString = CollectionNameString>(
257	currentUser: DbUser \| UsersCurrent \| null,
258	resolverArgs?: Record<string, unknown> \| null,
259	prefixGenerator?: PrefixGenerator,
260	): ProjectionContext<N> {
261	const baseTypeName = this.getBaseTypeName();	4✔
262	const collection = getCollectionByTypeName(baseTypeName);	4✔
263	const context = new ProjectionContext(collection, undefined, prefixGenerator);	4✔
264	context.setCurrentUser(currentUser);	4✔
265	context.addResolverArgs(resolverArgs ?? {});	4✔
266	this.compileProjection(context);	4✔
267	return context;	4✔
268	}
269	}
270
271	export default SqlFragment;	43✔

ForumMagnum / ForumMagnum / 9429574795

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous