create-joist-app 1.0.0 → 1.0.2

package/templates/graphql/joist-config.json

@@ -0,0 +1,8 @@
+{
+  "codegenPlugins": ["joist-graphql-codegen"],
+  "contextType": "Context@src/context",
+  "entities": { "Author": { "tag": "a" }, "Book": { "tag": "b" } },
+  "entitiesDirectory": "./src/entities",
+  "idType": "tagged-string",
+  "version": "0.0.0"
+}

package/templates/graphql/migrations/1580658856631_initial.ts

@@ -0,0 +1,38 @@
+import {
+  createCreatedAtFunction,
+  createEntityTable,
+  createUpdatedAtFunction,
+  foreignKey,
+} from "joist-migration-utils";
+import { MigrationBuilder } from "node-pg-migrate";
+
+export function up(b: MigrationBuilder): void {
+  createUpdatedAtFunction(b);
+  createCreatedAtFunction(b);
+
+  // Create flush_database function for test cleanup
+  b.sql(`
+    CREATE OR REPLACE FUNCTION flush_database() RETURNS void AS $$
+    DECLARE
+      tables CURSOR FOR
+        SELECT tablename FROM pg_tables
+        WHERE schemaname = 'public'
+        AND tablename != 'pgmigrations';
+    BEGIN
+      FOR t IN tables LOOP
+        EXECUTE 'TRUNCATE TABLE ' || quote_ident(t.tablename) || ' CASCADE';
+      END LOOP;
+    END;
+    $$ LANGUAGE plpgsql;
+  `);
+
+  createEntityTable(b, "authors", {
+    first_name: { type: "varchar(255)", notNull: true },
+    last_name: { type: "varchar(255)", notNull: false },
+  });
+
+  createEntityTable(b, "books", {
+    title: { type: "varchar(255)", notNull: true },
+    author_id: foreignKey("authors", { notNull: true }),
+  });
+}

package/templates/graphql/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "graphql-template",
+  "version": "0.1.0",
+  "private": true,
+  "scripts": {
+    "build": "tsc",
+    "start": "tsx src/server.ts",
+    "dev": "tsx watch src/server.ts",
+    "test": "env-cmd jest --runInBand",
+    "codegen": "env-cmd yarn joist-codegen && yarn graphql-codegen",
+    "graphql-codegen": "graphql-codegen --config graphql-codegen.js",
+    "format": "prettier --write \"src/**/*.{ts,tsx,graphql}\""
+  },
+  "dependencies": {
+    "@apollo/server": "^4.11.0",
+    "@graphql-tools/graphql-file-loader": "^8.0.0",
+    "@graphql-tools/load": "^8.0.0",
+    "@graphql-tools/merge": "^9.0.0",
+    "graphql": "^16.9.0",
+    "joist-orm": "2.0.3-next.36",
+    "knex": "^3.1.0",
+    "pg": "^8.16.3"
+  },
+  "devDependencies": {
+    "@graphql-codegen/cli": "^5.0.0",
+    "@graphql-codegen/typescript": "^4.0.0",
+    "@graphql-codegen/typescript-resolvers": "^4.0.0",
+    "@homebound/graphql-typescript-possible-types": "^2.19.0",
+    "@homebound/graphql-typescript-resolver-scaffolding": "^2.49.0",
+    "@homebound/graphql-typescript-simple-resolvers": "^1.58.0",
+    "@swc/core": "^1.13.0",
+    "@swc/jest": "^0.2.39",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^24.0.0",
+    "env-cmd": "^11.0.0",
+    "jest": "^30.0.0",
+    "prettier": "^3.6.0",
+    "tsx": "^4.20.0",
+    "typescript": "^5.9.0"
+  }
+}

package/templates/graphql/schema/.history.json

@@ -0,0 +1,9 @@
+{
+  "Author": ["books", "createdAt", "firstName", "id", "lastName", "updatedAt"],
+  "Book": ["author", "createdAt", "id", "title", "updatedAt"],
+  "Mutation": ["saveAuthor", "saveBook"],
+  "SaveAuthorInput": ["firstName", "id", "lastName"],
+  "SaveAuthorResult": ["author"],
+  "SaveBookInput": ["authorId", "id", "title"],
+  "SaveBookResult": ["book"]
+}

package/templates/graphql/schema/author.graphql

@@ -0,0 +1,20 @@
+extend type Mutation {
+  saveAuthor(input: SaveAuthorInput!): SaveAuthorResult!
+}
+
+type Author {
+  id: ID!
+  firstName: String!
+  lastName: String
+  books: [Book!]!
+}
+
+input SaveAuthorInput {
+  id: ID
+  firstName: String
+  lastName: String
+}
+
+type SaveAuthorResult {
+  author: Author!
+}

package/templates/graphql/schema/book.graphql

@@ -0,0 +1,19 @@
+extend type Mutation {
+  saveBook(input: SaveBookInput!): SaveBookResult!
+}
+
+type Book {
+  id: ID!
+  title: String!
+  author: Author!
+}
+
+input SaveBookInput {
+  id: ID
+  title: String
+  authorId: ID
+}
+
+type SaveBookResult {
+  book: Book!
+}

package/templates/graphql/src/.history.json

@@ -0,0 +1,12 @@
+{
+  "files": [
+    "resolvers/author/authorResolvers.test.ts",
+    "resolvers/author/authorResolvers.ts",
+    "resolvers/author/saveAuthorMutation.test.ts",
+    "resolvers/author/saveAuthorMutation.ts",
+    "resolvers/book/bookResolvers.test.ts",
+    "resolvers/book/bookResolvers.ts",
+    "resolvers/book/saveBookMutation.test.ts",
+    "resolvers/book/saveBookMutation.ts"
+  ]
+}

package/templates/graphql/src/context.ts

@@ -0,0 +1,14 @@
+import { EntityManager, newPgConnectionConfig } from "joist-orm";
+import { PostgresDriver } from "joist-orm/pg";
+import { Pool } from "pg";
+
+export interface Context {
+  pool: Pool;
+  em: EntityManager;
+}
+
+export function newContext(): Context {
+  const pool = new Pool(newPgConnectionConfig());
+  const em = new EntityManager({}, new PostgresDriver(pool));
+  return { em, pool };
+}

package/templates/graphql/src/entities/Author.test.ts

@@ -0,0 +1,36 @@
+import { newEm } from "../setupTests";
+import { newAuthor, newBook } from "./factories";
+
+describe("Author", () => {
+  it("can create an author", async () => {
+    const em = newEm();
+    const author = newAuthor(em, { firstName: "John", lastName: "Doe" });
+    await em.flush();
+
+    const loaded = await em.load(author.constructor, author.id);
+    expect(loaded).toMatchEntity({ firstName: "John", lastName: "Doe" });
+  });
+
+  it("has a full name", async () => {
+    const em = newEm();
+    const author = newAuthor(em, { firstName: "Jane", lastName: "Smith" });
+    expect(author.fullName).toBe("Jane Smith");
+  });
+
+  it("handles missing last name in fullName", async () => {
+    const em = newEm();
+    const author = newAuthor(em, { firstName: "Jane" });
+    expect(author.fullName).toBe("Jane");
+  });
+
+  it("can have books", async () => {
+    const em = newEm();
+    const author = newAuthor(em, { firstName: "Test", lastName: "Author" });
+    const book = newBook(em, { title: "Test Book", author });
+    await em.flush();
+
+    const books = await author.books.load();
+    expect(books).toHaveLength(1);
+    expect(books[0]).toMatchEntity({ title: "Test Book" });
+  });
+});

package/templates/graphql/src/entities/Author.ts

@@ -0,0 +1,7 @@
+import { AuthorCodegen } from "./codegen/AuthorCodegen";
+
+export class Author extends AuthorCodegen {
+  get fullName(): string {
+    return `${this.firstName} ${this.lastName || ""}`.trim();
+  }
+}

package/templates/graphql/src/entities/Book.ts

@@ -0,0 +1,3 @@
+import { BookCodegen } from "./codegen/BookCodegen";
+
+export class Book extends BookCodegen {}

package/templates/graphql/src/entities/entities.ts

@@ -0,0 +1,14 @@
+// organize-imports-ignore
+
+// This file drives our import order to avoid undefined errors
+// when the subclasses extend the base classes, see:
+// https://medium.com/visual-development/how-to-fix-nasty-circular-dependency-issues-once-and-for-all-in-javascript-typescript-a04c987cf0de
+
+export * from "./codegen/AuthorCodegen";
+export * from "./codegen/BookCodegen";
+export * from "./Author";
+export * from "./Book";
+
+export * from "./factories/newAuthor";
+export * from "./factories/newBook";
+export * from "./codegen/metadata";

package/templates/graphql/src/entities/factories/index.ts

@@ -0,0 +1,2 @@
+export * from "./newAuthor";
+export * from "./newBook";

package/templates/graphql/src/entities/factories/newAuthor.ts

@@ -0,0 +1,6 @@
+import { EntityManager, FactoryOpts, newTestInstance } from "joist-orm";
+import { Author } from "../Author";
+
+export function newAuthor(em: EntityManager, opts?: FactoryOpts<Author>): Author {
+  return newTestInstance(em, Author, opts);
+}

package/templates/graphql/src/entities/factories/newBook.ts

@@ -0,0 +1,6 @@
+import { EntityManager, FactoryOpts, newTestInstance } from "joist-orm";
+import { Book } from "../Book";
+
+export function newBook(em: EntityManager, opts?: FactoryOpts<Book>): Book {
+  return newTestInstance(em, Book, opts);
+}

package/templates/graphql/src/entities/index.ts

@@ -0,0 +1,3 @@
+export * from "./entities";
+export * from "./Author";
+export * from "./Book";

package/templates/graphql/src/jest.d.ts

@@ -0,0 +1,9 @@
+declare namespace jest {
+  type ContextOpts = Partial<import("./context").Context & import("./context").AppContext>;
+  type itWithCtxFn = (ctx: import("./context").Context) => Promise<void>;
+
+  interface It {
+    withCtx(name: string, fn: itWithCtxFn): void;
+    withCtx(name: string, opts: ContextOpts, fn: itWithCtxFn): void;
+  }
+}

package/templates/graphql/src/resolvers/author/authorResolvers.test.ts

@@ -0,0 +1,17 @@
+import { newAuthor } from "src/entities";
+import { authorResolvers } from "src/resolvers/author/authorResolvers";
+import { makeRunObjectField, makeRunObjectFields } from "src/resolvers/testUtils";
+
+describe("authorResolvers", () => {
+  it.withCtx("can return", async (ctx) => {
+    const { em } = ctx;
+    // Given a Author
+    const a = newAuthor(em);
+    // Then we can query it
+    const result = await runFields(ctx, a, ["firstName", "lastName", "createdAt", "updatedAt"]);
+    expect(result).toMatchEntity({});
+  });
+});
+
+const runFields = makeRunObjectFields(authorResolvers);
+const runField = makeRunObjectField(authorResolvers);

package/templates/graphql/src/resolvers/author/authorResolvers.ts

@@ -0,0 +1,5 @@
+import { Author } from "src/entities";
+import type { AuthorResolvers } from "src/generated/graphql-types";
+import { entityResolver } from "src/resolvers/utils";
+
+export const authorResolvers: AuthorResolvers = { ...entityResolver(Author) };

package/templates/graphql/src/resolvers/author/saveAuthorMutation.test.ts

@@ -0,0 +1,13 @@
+import { saveAuthor } from "src/resolvers/author/saveAuthorMutation";
+import { makeRunInputMutation } from "src/resolvers/testUtils";
+
+describe("saveAuthor", () => {
+  it.withCtx("can create", async (ctx) => {
+    const result = await runSave(ctx, () => ({
+      firstName: "Test",
+    }));
+    expect(result).toBeDefined();
+  });
+});
+
+const runSave = makeRunInputMutation(saveAuthor);

package/templates/graphql/src/resolvers/author/saveAuthorMutation.ts

@@ -0,0 +1,9 @@
+import { Author } from "src/entities";
+import type { MutationResolvers } from "src/generated/graphql-types";
+import { saveEntity } from "src/resolvers/utils";
+
+export const saveAuthor: Pick<MutationResolvers, "saveAuthor"> = {
+  async saveAuthor(_, args, ctx) {
+    return { author: await saveEntity(ctx, Author, args.input) };
+  },
+};

package/templates/graphql/src/resolvers/book/bookResolvers.test.ts

@@ -0,0 +1,17 @@
+import { newBook } from "src/entities";
+import { bookResolvers } from "src/resolvers/book/bookResolvers";
+import { makeRunObjectField, makeRunObjectFields } from "src/resolvers/testUtils";
+
+describe("bookResolvers", () => {
+  it.withCtx("can return", async (ctx) => {
+    const { em } = ctx;
+    // Given a Book
+    const b = newBook(em);
+    // Then we can query it
+    const result = await runFields(ctx, b, ["title", "createdAt", "updatedAt"]);
+    expect(result).toMatchEntity({});
+  });
+});
+
+const runFields = makeRunObjectFields(bookResolvers);
+const runField = makeRunObjectField(bookResolvers);

package/templates/graphql/src/resolvers/book/bookResolvers.ts

@@ -0,0 +1,5 @@
+import { Book } from "src/entities";
+import type { BookResolvers } from "src/generated/graphql-types";
+import { entityResolver } from "src/resolvers/utils";
+
+export const bookResolvers: BookResolvers = { ...entityResolver(Book) };

package/templates/graphql/src/resolvers/book/saveBookMutation.test.ts

@@ -0,0 +1,16 @@
+import { newAuthor } from "src/entities/index";
+import { saveBook } from "src/resolvers/book/saveBookMutation";
+import { makeRunInputMutation } from "src/resolvers/testUtils";
+
+describe("saveBook", () => {
+  it.withCtx("can create", async (ctx) => {
+    const a = newAuthor(ctx.em);
+    const result = await runSave(ctx, () => ({
+      title: "Test Book",
+      authorId: a.id,
+    }));
+    expect(result).toBeDefined();
+  });
+});
+
+const runSave = makeRunInputMutation(saveBook);

package/templates/graphql/src/resolvers/book/saveBookMutation.ts

@@ -0,0 +1,9 @@
+import { Book } from "src/entities";
+import type { MutationResolvers } from "src/generated/graphql-types";
+import { saveEntity } from "src/resolvers/utils";
+
+export const saveBook: Pick<MutationResolvers, "saveBook"> = {
+  async saveBook(_, args, ctx) {
+    return { book: await saveEntity(ctx, Book, args.input) };
+  },
+};

package/templates/graphql/src/resolvers/enumResolvers.ts

@@ -0,0 +1,5 @@
+import type { Resolvers } from "src/generated/graphql-types";
+
+type EnumDetails = never;
+
+export const enumResolvers: Pick<Resolvers, EnumDetails> = {};

package/templates/graphql/src/resolvers/index.ts

@@ -0,0 +1,15 @@
+import { authorResolvers } from "./authorResolvers";
+import { bookResolvers } from "./bookResolvers";
+
+export const resolvers = {
+  Query: {
+    ...authorResolvers.Query,
+    ...bookResolvers.Query,
+  },
+  Mutation: {
+    ...authorResolvers.Mutation,
+    ...bookResolvers.Mutation,
+  },
+  Author: authorResolvers.Author,
+  Book: bookResolvers.Book,
+};

package/templates/graphql/src/resolvers/mutations/index.ts

@@ -0,0 +1,7 @@
+import type { MutationResolvers } from "src/generated/graphql-types";
+import { saveAuthor } from "src/resolvers/author/saveAuthorMutation";
+import { saveBook } from "src/resolvers/book/saveBookMutation";
+
+// This file is auto-generated
+
+export const mutationResolvers: MutationResolvers = { ...saveAuthor, ...saveBook };

package/templates/graphql/src/resolvers/objects/index.ts

@@ -0,0 +1,6 @@
+import { authorResolvers } from "src/resolvers/author/authorResolvers";
+import { bookResolvers } from "src/resolvers/book/bookResolvers";
+
+// This file is auto-generated
+
+export const objectResolvers = { Author: authorResolvers, Book: bookResolvers };

package/templates/graphql/src/resolvers/testUtils.ts

@@ -0,0 +1,10 @@
+import {
+  makeMakeRunInputMutation,
+  makeMakeRunObjectField,
+  makeMakeRunObjectFields,
+} from "joist-graphql-resolver-utils/tests";
+import { run } from "joist-orm/tests";
+
+export const makeRunObjectField = makeMakeRunObjectField(run);
+export const makeRunObjectFields = makeMakeRunObjectFields(run);
+export const makeRunInputMutation = makeMakeRunInputMutation(run);

package/templates/graphql/src/resolvers/utils.ts

@@ -0,0 +1 @@
+export { entityResolver, saveEntities, saveEntity } from "joist-orm/graphql";

package/templates/graphql/src/server.ts

@@ -0,0 +1,37 @@
+import { ApolloServer } from "@apollo/server";
+import { startStandaloneServer } from "@apollo/server/standalone";
+import { loadSchemaSync } from "@graphql-tools/load";
+import { GraphQLFileLoader } from "@graphql-tools/graphql-file-loader";
+import { EntityManager } from "joist-orm";
+import { newPgConnectionConfig } from "joist-orm/pg";
+import knex from "knex";
+import path from "path";
+import { Context } from "./context";
+import { entities } from "./entities";
+import { resolvers } from "./resolvers";
+
+const typeDefs = loadSchemaSync(path.join(__dirname, "./**/*.graphql"), {
+  loaders: [new GraphQLFileLoader()],
+});
+
+async function main() {
+  const config = newPgConnectionConfig();
+  const db = knex({ client: "pg", connection: config });
+
+  const server = new ApolloServer<Context>({
+    typeDefs,
+    resolvers,
+  });
+
+  const { url } = await startStandaloneServer(server, {
+    listen: { port: parseInt(process.env.PORT || "4000") },
+    context: async () => {
+      const em = new EntityManager({ entities, driver: db }, {});
+      return { em };
+    },
+  });
+
+  console.log(`🚀 Server ready at ${url}`);
+}
+
+main().catch(console.error);

package/templates/graphql/src/setupIt.ts

@@ -0,0 +1,17 @@
+import { createTestContext } from "src/setupTests";
+
+it.withCtx = (name: string, fnOrOpts: jest.itWithCtxFn | jest.ContextOpts, maybeFn?: jest.itWithCtxFn) => {
+  const fn: jest.itWithCtxFn = typeof fnOrOpts === "function" ? fnOrOpts : maybeFn!;
+  const opts: jest.ContextOpts = typeof fnOrOpts === "function" ? {} : fnOrOpts;
+  it(name, async () => fn(await createTestContext(opts)));
+};
+
+it.skip.withCtx = (name: string, fnOrOpts: jest.itWithCtxFn | jest.ContextOpts, maybeFn?: jest.itWithCtxFn) =>
+  it.skip(name, () => {});
+it.only.withCtx = (name: string, fnOrOpts: jest.itWithCtxFn | jest.ContextOpts, maybeFn?: jest.itWithCtxFn) => {
+  const fn: jest.itWithCtxFn = typeof fnOrOpts === "function" ? fnOrOpts : maybeFn!;
+  const opts: jest.ContextOpts = typeof fnOrOpts === "function" ? {} : fnOrOpts;
+  it.only(name, async () => fn(await createTestContext(opts)));
+};
+xit.withCtx = it.skip.withCtx;
+fit.withCtx = it.only.withCtx;

package/templates/graphql/src/setupTestEnv.ts

@@ -0,0 +1,5 @@
+import { GetEnvVars } from "env-cmd";
+
+export default async function globalSetup() {
+  Object.entries(await GetEnvVars()).forEach(([key, value]) => (process.env[key] = value));
+}

package/templates/graphql/src/setupTests.ts

@@ -0,0 +1,37 @@
+import expect from "expect";
+import { newPgConnectionConfig } from "joist-orm";
+import { PostgresDriver } from "joist-orm/pg";
+import { toMatchEntity } from "joist-orm/tests";
+import pg from "pg";
+import "src/setupIt";
+import { Context } from "./context";
+import { EntityManager } from "./entities";
+
+expect.extend({ toMatchEntity });
+
+let pool: pg.Pool;
+
+beforeAll(async () => {
+  pool = new pg.Pool(newPgConnectionConfig());
+});
+
+beforeEach(async () => {
+  await pool.query("select flush_database()");
+});
+
+afterAll(async () => {
+  await pool.end();
+});
+
+export function newEm(): EntityManager {
+  const driver = new PostgresDriver(pool);
+  const ctx = { pool, em: null as any } satisfies Context;
+  const em = new EntityManager(ctx, driver);
+  Object.assign(ctx, { em });
+  return em;
+}
+
+export async function createTestContext(opts: {}): Promise<Context> {
+  const em = newEm();
+  return em.ctx;
+}

package/templates/graphql/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "nodenext",
+    "lib": ["ES2022"],
+    "moduleResolution": "nodenext",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./build",
+    "rootDir": "./src",
+    "baseUrl": "./src",
+    "paths": {
+      "src/*": ["./*"]
+    }
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "build"]
+}