joist-codegen 0.1.538 → 1.0.0

package/src/config.ts

@@ -1,82 +0,0 @@
-import { Entity } from "EntityDbMetadata";
-import { promises as fs } from "fs";
-import prettier, { resolveConfig } from "prettier";
-import { sortKeys, trueIfResolved } from "./utils";
-
-export interface FieldConfig {
-  derived?: "sync" | "async";
-  protected?: boolean;
-}
-
-export interface RelationConfig {
-  name?: string;
-}
-
-export interface EntityConfig {
-  tag: string;
-  tableName?: string;
-  fields?: Record<string, FieldConfig>;
-  relations?: Record<string, RelationConfig>;
-}
-
-export interface Config {
-  contextType?: string;
-  entitiesDirectory: string;
-  codegenPlugins: string[];
-  entities: Record<string, EntityConfig>;
-  // We don't persist this, and instead just use it as a cache
-  __tableToEntityName: Record<string, string>;
-}
-
-export const defaultConfig: Config = {
-  entitiesDirectory: "./src/entities",
-  codegenPlugins: [],
-  entities: {},
-  __tableToEntityName: {},
-};
-
-export const ormMaintainedFields = ["createdAt", "updatedAt"];
-
-export function isDerived(config: Config, entity: Entity, fieldName: string): boolean {
-  return config.entities[entity.name]?.fields?.[fieldName]?.derived === "sync";
-}
-
-export function isAsyncDerived(config: Config, entity: Entity, fieldName: string): boolean {
-  return config.entities[entity.name]?.fields?.[fieldName]?.derived === "async";
-}
-
-export function isProtected(config: Config, entity: Entity, fieldName: string): boolean {
-  return config.entities[entity.name]?.fields?.[fieldName]?.protected === true;
-}
-
-export function relationName(config: Config, entity: Entity, relationName: string): string {
-  return config.entities?.[entity.name]?.relations?.[relationName]?.name ?? relationName;
-}
-
-const configPath = "./joist-codegen.json";
-export async function loadConfig(): Promise<Config> {
-  const exists = await trueIfResolved(fs.access(configPath));
-  if (exists) {
-    const content = await fs.readFile(configPath);
-    return {
-      ...defaultConfig,
-      ...(JSON.parse(content.toString()) as Config),
-    };
-  }
-  return defaultConfig;
-}
-
-/**
- * Writes the potentially-updated config entry back to `joist-codegen.json`.
- *
- * We format the output with prettier so it should both a) look nice and b) be deterministic,
- * such that no changes to the config show up as noops to the scm.
- */
-export async function writeConfig(config: Config): Promise<void> {
-  const prettierConfig = await resolveConfig("./");
-  const sorted = sortKeys(config);
-  delete sorted.__tableToEntityName;
-  const input = JSON.stringify(sorted);
-  const content = prettier.format(input.trim(), { parser: "json", ...prettierConfig });
-  await fs.writeFile(configPath, content);
-}

package/src/generateEntitiesFile.ts

@@ -1,26 +0,0 @@
-import { Table } from "pg-structure";
-import { code, Code } from "ts-poet";
-import { Config } from "./config";
-import { EntityDbMetadata } from "./EntityDbMetadata";
-import { tableToEntityName } from "./utils";
-
-export function generateEntitiesFile(config: Config, entities: EntityDbMetadata[], enums: Table[]): Code {
-  return code`
-    // 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
-    ${enums.map((table) => {
-      return `export * from "./${tableToEntityName(config, table)}";`;
-    })}
-    ${entities.map((meta) => {
-      return `export * from "./${meta.entity.name}Codegen";`;
-    })}
-    ${entities.map((meta) => {
-      return `export * from "./${meta.entity.name}";`;
-    })}
-    export * from "./factories";
-    export * from "./metadata";
-  `;
-}

package/src/generateEntityCodegenFile.ts

@@ -1,414 +0,0 @@
-import { camelCase, pascalCase } from "change-case";
-import { code, Code, imp } from "ts-poet";
-import { SymbolSpec } from "ts-poet/build/SymbolSpecs";
-import { Config } from "./config";
-import { EntityDbMetadata, PrimitiveField } from "./EntityDbMetadata";
-import {
-  BaseEntity,
-  BooleanFilter,
-  BooleanGraphQLFilter,
-  Changes,
-  Collection,
-  ConfigApi,
-  EntityFilter,
-  EntityGraphQLFilter,
-  EntityManager,
-  EnumGraphQLFilter,
-  FilterOf,
-  Flavor,
-  getEm,
-  GraphQLFilterOf,
-  hasMany,
-  hasManyToMany,
-  hasOne,
-  hasOneToOne,
-  Lens,
-  Loaded,
-  LoadHint,
-  loadLens,
-  newChangesProxy,
-  newRequiredRule,
-  OptsOf,
-  OrderBy,
-  PartialOrNull,
-  Reference,
-  setField,
-  setOpts,
-  ValueFilter,
-  ValueGraphQLFilter,
-} from "./symbols";
-
-export interface ColumnMetaData {
-  typeConverter?: SymbolSpec;
-  fieldType: SymbolSpec | string;
-}
-
-/** Creates the base class with the boilerplate annotations. */
-export function generateEntityCodegenFile(config: Config, meta: EntityDbMetadata): Code {
-  const { entity } = meta;
-  const entityName = entity.name;
-
-  // Add the primitives
-  const primitives = meta.primitives.map((p) => {
-    const { fieldName, fieldType, notNull } = p;
-    const maybeOptional = notNull ? "" : " | undefined";
-
-    let getter: Code;
-    if (p.derived === "async") {
-      getter = code`
-        get ${fieldName}(): ${fieldType}${maybeOptional} {
-          if (!("${fieldName}" in this.__orm.data)) {
-            throw new Error("${fieldName} has not been derived yet");
-          }
-          return this.__orm.data["${fieldName}"];
-        }
-     `;
-    } else if (p.derived === "sync") {
-      getter = code`
-        abstract get ${fieldName}(): ${fieldType}${maybeOptional};
-     `;
-    } else {
-      getter = code`
-        get ${fieldName}(): ${fieldType}${maybeOptional} {
-          return this.__orm.data["${fieldName}"];
-        }
-     `;
-    }
-
-    let setter: Code | string;
-    if (p.protected) {
-      // TODO Allow making the getter to be protected as well. And so probably remove it
-      // from the Opts as well. Wonder how that works for required protected fields?
-      //
-      // We have to use a method of `set${fieldName}` because TS enforces getters/setters to have
-      // same access level and currently we're leaving the getter as public.
-      setter = code`
-        protected set${pascalCase(fieldName)}(${fieldName}: ${fieldType}${maybeOptional}) {
-          ${setField}(this, "${fieldName}", ${fieldName});
-        }
-      `;
-    } else if (p.derived) {
-      setter = "";
-    } else {
-      setter = code`
-        set ${fieldName}(${fieldName}: ${fieldType}${maybeOptional}) {
-          ${setField}(this, "${fieldName}", ${fieldName});
-        }
-      `;
-    }
-
-    return code`${getter} ${setter}`;
-  });
-
-  // Add ManyToOne enums
-  meta.enums.forEach((e) => {
-    const { fieldName, enumType, notNull } = e;
-    const maybeOptional = notNull ? "" : " | undefined";
-    const getter = code`
-      get ${fieldName}(): ${enumType}${maybeOptional} {
-        return this.__orm.data["${fieldName}"];
-      }
-   `;
-    const setter = code`
-      set ${fieldName}(${fieldName}: ${enumType}${maybeOptional}) {
-        ${setField}(this, "${fieldName}", ${fieldName});
-      }
-    `;
-    // Group enums as primitives
-    primitives.push(getter);
-    primitives.push(setter);
-  });
-
-  // Add ManyToOne entities
-  const m2o = meta.manyToOnes.map((m2o) => {
-    const { fieldName, otherEntity, otherFieldName, notNull } = m2o;
-    const maybeOptional = notNull ? "never" : "undefined";
-    return code`
-      readonly ${fieldName}: ${Reference}<${entity.type}, ${otherEntity.type}, ${maybeOptional}> =
-        ${hasOne}(
-          ${otherEntity.metaType},
-          "${fieldName}",
-          "${otherFieldName}",
-        );
-    `;
-  });
-
-  // Add OneToMany
-  const o2m = meta.oneToManys.map((o2m) => {
-    const { fieldName, otherFieldName, otherColumnName, otherEntity } = o2m;
-    return code`
-      readonly ${fieldName}: ${Collection}<${entity.type}, ${otherEntity.type}> = ${hasMany}(
-        ${otherEntity.metaType},
-        "${fieldName}",
-        "${otherFieldName}",
-        "${otherColumnName}"
-      );
-    `;
-  });
-
-  // Add OneToOne
-  const o2o = meta.oneToOnes.map((o2o) => {
-    const { fieldName, otherEntity, otherFieldName } = o2o;
-    return code`
-      readonly ${fieldName}: ${Reference}<${entity.type}, ${otherEntity.type}, undefined> =
-        ${hasOneToOne}(
-          ${otherEntity.metaType},
-          "${fieldName}",
-          "${otherFieldName}",
-        );
-    `;
-  });
-
-  // Add ManyToMany
-  const m2m = meta.manyToManys.map((m2m) => {
-    const { joinTableName, fieldName, columnName, otherEntity, otherFieldName, otherColumnName } = m2m;
-    return code`
-      readonly ${fieldName}: ${Collection}<${entity.type}, ${otherEntity.type}> = ${hasManyToMany}(
-        "${joinTableName}",
-        "${fieldName}",
-        "${columnName}",
-        ${otherEntity.metaType},
-        "${otherFieldName}",
-        "${otherColumnName}",
-      );
-    `;
-  });
-
-  const configName = `${camelCase(entityName)}Config`;
-  const metadata = imp(`${camelCase(entityName)}Meta@./entities`);
-
-  const defaultValues = generateDefaultValues(config, meta);
-  const hasDefaultValues = defaultValues.length > 0;
-  const defaultValuesName = `${camelCase(entityName)}DefaultValues`;
-
-  const contextType = config.contextType ? imp(config.contextType) : "{}";
-  const factoryMethod = imp(`new${entity.name}@./entities`);
-
-  return code`
-    export type ${entityName}Id = ${Flavor}<string, "${entityName}">;
-
-    export interface ${entityName}Opts {
-      ${generateOptsFields(config, meta)}
-    }
-    
-    export interface ${entityName}IdsOpts {
-      ${generateOptIdsFields(config, meta)}
-    }
-
-    export interface ${entityName}Filter {
-      id?: ${ValueFilter}<${entityName}Id, never>;
-      ${generateFilterFields(meta)}
-    }
-
-    export interface ${entityName}GraphQLFilter {
-      id?: ${ValueGraphQLFilter}<${entityName}Id>;
-      ${generateGraphQLFilterFields(meta)}
-    }
-
-    export interface ${entityName}Order {
-      id?: ${OrderBy};
-      ${generateOrderFields(meta)}
-    }
-    
-    ${hasDefaultValues ? code`export const ${defaultValuesName} = { ${defaultValues} };` : ""}
-
-    export const ${configName} = new ${ConfigApi}<${entity.type}, ${contextType}>();
-
-    ${generateDefaultValidationRules(meta, configName)}
-  
-    export abstract class ${entityName}Codegen extends ${BaseEntity} {
-      readonly __types: {
-        filterType: ${entityName}Filter;
-        gqlFilterType: ${entityName}GraphQLFilter;
-        orderType: ${entityName}Order;
-        optsType: ${entityName}Opts;
-        optIdsType: ${entityName}IdsOpts;
-        factoryOptsType: Parameters<typeof ${factoryMethod}>[1];
-      } = null!;
-      ${[o2m, m2o, o2o, m2m]}
-
-      constructor(em: ${EntityManager}, opts: ${entityName}Opts) {
-        super(em, ${metadata}, ${hasDefaultValues ? `${defaultValuesName}` : "{}"}, opts);
-        ${setOpts}(this as any as ${entityName}, opts, { calledFromConstructor: true });
-      }
-
-      get id(): ${entityName}Id | undefined {
-        return this.__orm.data["id"];
-      }
-
-      ${primitives}
-
-      set(opts: Partial<${entityName}Opts>): void {
-        ${setOpts}(this as any as ${entityName}, opts);
-      }
-
-      setPartial(opts: ${PartialOrNull}<${entityName}Opts>): void {
-        ${setOpts}(this as any as ${entityName}, opts as ${OptsOf}<${entityName}>, { partial: true });
-      }
-
-      get changes(): ${Changes}<${entityName}> {
-        return ${newChangesProxy}(this as any as ${entityName});
-      }
-
-      async load<U, V>(fn: (lens: ${Lens}<${entity.type}>) => ${Lens}<U, V>): Promise<V> {
-        return ${loadLens}(this as any as ${entityName}, fn);
-      }
-
-      async populate<H extends ${LoadHint}<${entityName}>>(hint: H): Promise<${Loaded}<${entityName}, H>> {
-        return ${getEm}(this).populate(this as any as ${entityName}, hint);
-      }
-    }
-  `;
-}
-
-function fieldHasDefaultValue(config: Config, meta: EntityDbMetadata, field: PrimitiveField): boolean {
-  let { fieldName, columnDefault, columnType } = field;
-
-  // if there's no default at all, return false
-  if (columnDefault === null) {
-    return false;
-  }
-
-  // even though default is defined as a number | boolean | string | null in reality pg-structure
-  // only ever returns a string | null so we make sure of that here
-  columnDefault = columnDefault.toString();
-
-  // if this value should be set elsewhere, return false
-  if (field.derived !== false) {
-    return false;
-  }
-
-  // try to validate that we actually got a primitive value and not arbitrary SQL
-  return (
-    (["smallint", "int", "bigint"].includes(columnType) && !isNaN(parseInt(columnDefault))) ||
-    (["varchar", "text"].includes(columnType) && /^'.*'$/.test(columnDefault)) ||
-    ("bool" === columnType && ["true", "false"].includes(columnDefault))
-  );
-}
-
-function generateDefaultValues(config: Config, meta: EntityDbMetadata): Code[] {
-  return meta.primitives
-    .filter((field) => fieldHasDefaultValue(config, meta, field))
-    .map(({ fieldName, columnDefault }) => {
-      return code`${fieldName}: ${columnDefault},`;
-    });
-}
-
-function generateDefaultValidationRules(meta: EntityDbMetadata, configName: string): Code[] {
-  const fields = [...meta.primitives, ...meta.enums, ...meta.manyToOnes];
-  return fields
-    .filter((p) => p.notNull)
-    .map(({ fieldName }) => {
-      return code`${configName}.addRule(${newRequiredRule}("${fieldName}"));`;
-    });
-}
-
-// Make our opts type
-function generateOptsFields(config: Config, meta: EntityDbMetadata): Code[] {
-  const primitives = meta.primitives.map((field) => {
-    const { fieldName, fieldType, notNull, derived } = field;
-    if (derived) {
-      return code``;
-    }
-    return code`${fieldName}${maybeOptional(
-      notNull && !fieldHasDefaultValue(config, meta, field),
-    )}: ${fieldType}${maybeUnionNull(notNull)};`;
-  });
-  const enums = meta.enums.map(({ fieldName, enumType, notNull }) => {
-    return code`${fieldName}${maybeOptional(notNull)}: ${enumType}${maybeUnionNull(notNull)};`;
-  });
-  const m2o = meta.manyToOnes.map(({ fieldName, otherEntity, notNull }) => {
-    return code`${fieldName}${maybeOptional(notNull)}: ${otherEntity.type}${maybeUnionNull(notNull)};`;
-  });
-  const o2o = meta.oneToOnes.map(({ fieldName, otherEntity }) => {
-    return code`${fieldName}?: ${otherEntity.type} | null;`;
-  });
-  const o2m = meta.oneToManys.map(({ fieldName, otherEntity }) => {
-    return code`${fieldName}?: ${otherEntity.type}[];`;
-  });
-  const m2m = meta.manyToManys.map(({ fieldName, otherEntity }) => {
-    return code`${fieldName}?: ${otherEntity.type}[];`;
-  });
-  return [...primitives, ...enums, ...m2o, ...o2o, ...o2m, ...m2m];
-}
-
-// We know the OptIds types are only used in partials, so we make everything optional.
-// This especially needs to be the case b/c both `book: ...` and `bookId: ...` will be
-// in the partial type and of course the caller will only be setting one.
-function generateOptIdsFields(config: Config, meta: EntityDbMetadata): Code[] {
-  const m2o = meta.manyToOnes.map(({ fieldName, otherEntity, notNull }) => {
-    return code`${fieldName}Id?: ${otherEntity.idType} | null;`;
-  });
-  const o2o = meta.oneToOnes.map(({ fieldName, otherEntity }) => {
-    return code`${fieldName}Id?: ${otherEntity.idType} | null;`;
-  });
-  const o2m = meta.oneToManys.map(({ singularName, otherEntity }) => {
-    return code`${singularName}Ids?: ${otherEntity.idType}[] | null;`;
-  });
-  const m2m = meta.manyToManys.map(({ singularName, otherEntity }) => {
-    return code`${singularName}Ids?: ${otherEntity.idType}[] | null;`;
-  });
-  return [...m2o, ...o2o, ...o2m, ...m2m];
-}
-
-function generateFilterFields(meta: EntityDbMetadata): Code[] {
-  const primitives = meta.primitives.map(({ fieldName, fieldType, notNull }) => {
-    if (fieldType === "boolean") {
-      return code`${fieldName}?: ${BooleanFilter}<${nullOrNever(notNull)}>;`;
-    } else {
-      return code`${fieldName}?: ${ValueFilter}<${fieldType}, ${nullOrNever(notNull)}>;`;
-    }
-  });
-  const enums = meta.enums.map(({ fieldName, enumType, notNull }) => {
-    return code`${fieldName}?: ${ValueFilter}<${enumType}, ${nullOrNever(notNull)}>;`;
-  });
-  const m2o = meta.manyToOnes.map(({ fieldName, otherEntity, notNull }) => {
-    return code`${fieldName}?: ${EntityFilter}<${otherEntity.type}, ${otherEntity.idType}, ${FilterOf}<${
-      otherEntity.type
-    }>, ${nullOrNever(notNull)}>;`;
-  });
-  return [...primitives, ...enums, ...m2o];
-}
-
-function generateGraphQLFilterFields(meta: EntityDbMetadata): Code[] {
-  const primitives = meta.primitives.map(({ fieldName, fieldType, notNull }) => {
-    if (fieldType === "boolean") {
-      return code`${fieldName}?: ${BooleanGraphQLFilter};`;
-    } else {
-      return code`${fieldName}?: ${ValueGraphQLFilter}<${fieldType}>;`;
-    }
-  });
-  const enums = meta.enums.map(({ fieldName, enumType, notNull }) => {
-    return code`${fieldName}?: ${EnumGraphQLFilter}<${enumType}>;`;
-  });
-  const m2o = meta.manyToOnes.map(({ fieldName, otherEntity, notNull }) => {
-    return code`${fieldName}?: ${EntityGraphQLFilter}<${otherEntity.type}, ${otherEntity.idType}, ${GraphQLFilterOf}<${otherEntity.type}>>;`;
-  });
-  return [...primitives, ...enums, ...m2o];
-}
-
-function generateOrderFields(meta: EntityDbMetadata): Code[] {
-  // Make our opts type
-  const primitives = meta.primitives.map(({ fieldName }) => {
-    return code`${fieldName}?: ${OrderBy};`;
-  });
-  const enums = meta.enums.map(({ fieldName }) => {
-    return code`${fieldName}?: ${OrderBy};`;
-  });
-  const m2o = meta.manyToOnes.map(({ fieldName, otherEntity, notNull }) => {
-    return code`${fieldName}?: ${otherEntity.orderType};`;
-  });
-  return [...primitives, ...enums, ...m2o];
-}
-
-function maybeOptional(notNull: boolean): string {
-  return notNull ? "" : "?";
-}
-
-function maybeUnionNull(notNull: boolean): string {
-  return notNull ? "" : " | null";
-}
-
-function nullOrNever(notNull: boolean): string {
-  return notNull ? "never" : " null | undefined";
-}

package/src/generateEnumFile.ts

@@ -1,63 +0,0 @@
-import { pascalCase } from "change-case";
-import { Table } from "pg-structure";
-import pluralize from "pluralize";
-import { code, Code } from "ts-poet";
-import { Config } from "./config";
-import { EntityDbMetadata, EnumRows } from "./index";
-
-export function generateEnumFile(config: Config, table: Table, enumRows: EnumRows, enumName: string): Code {
-  const rows = enumRows[table.name];
-  const detailsName = `${enumName}Details`;
-  // We're not really an entity, but appropriate EntityDbMetadata's `primitives` filtering
-  const extraPrimitives = new EntityDbMetadata(config, table).primitives.filter(
-    (p) => !["code", "name"].includes(p.fieldName),
-  );
-  const detailsDefinition = [
-    "id: number;",
-    `code: ${enumName};`,
-    "name: string;",
-    ...extraPrimitives.map((primitive) => `${primitive.fieldName}: ${primitive.fieldType};`),
-  ].join(" ");
-  return code`
-    export enum ${enumName} {
-      ${rows.map((row) => `${pascalCase(row.code)} = '${row.code}'`).join(",\n")}
-    }
-
-    export type ${detailsName} = {${detailsDefinition}};
-
-    const details: Record<${enumName}, ${detailsName}> = {
-      ${rows
-        .map((row) => {
-          const code = pascalCase(row.code);
-          const safeName = row.name.replace(/(["'])/g, "\\$1");
-          const extras = extraPrimitives
-            .map((p) => `${p.fieldName}: ${JSON.stringify((row as any)[p.columnName])}`)
-            .join(", ");
-          return `[${enumName}.${code}]: { id: ${row.id}, code: ${enumName}.${code}, name: '${safeName}', ${extras} }`;
-        })
-        .join(",")}
-    };
-
-    export const ${pluralize(enumName)} = {
-      getByCode(code: ${enumName}): ${detailsName} {
-        return details[code];
-      },
-
-      findByCode(code: string): ${detailsName} | undefined {
-        return details[code as ${enumName}];
-      },
-
-      findById(id: number): ${detailsName} | undefined {
-        return Object.values(details).find(d => d.id === id);
-      },
-
-      getValues(): ReadonlyArray<${enumName}> {
-        return Object.values(${enumName});
-      },
-
-      getDetails(): ReadonlyArray<${detailsName}> {
-        return Object.values(details);
-      },
-    };
-  `;
-}

package/src/generateFactoriesFiles.ts

@@ -1,29 +0,0 @@
-import { pascalCase } from "change-case";
-import { code } from "ts-poet";
-import { EntityDbMetadata } from "./EntityDbMetadata";
-import { CodeGenFile } from "./index";
-import { EntityManager, FactoryOpts, New, newTestInstance } from "./symbols";
-
-export function generateFactoriesFiles(entities: EntityDbMetadata[]): CodeGenFile[] {
-  // One-time create an Author.factories.ts for each entity
-  const entityFiles = entities.map(({ entity }) => {
-    const name = pascalCase(entity.name);
-    const contents = code`
-      export function new${name}(
-        em: ${EntityManager},
-        opts?: ${FactoryOpts}<${entity.type}>
-      ): ${New}<${entity.type}> {
-        return ${newTestInstance}(em, ${entity.type}, opts);
-      }`;
-    return { name: `./${entity.name}.factories.ts`, contents, overwrite: false };
-  });
-
-  // Everytime create a factories.ts that exports the others
-  const factoriesFile = {
-    name: "./factories.ts",
-    contents: code`${entities.map(({ entity }) => code`export * from "./${entity.name}.factories";`)}`,
-    overwrite: true,
-  };
-
-  return [...entityFiles, factoriesFile];
-}

package/src/generateInitialEntityFile.ts

@@ -1,12 +0,0 @@
-import { code, Code, imp } from "ts-poet";
-import { EntityManager } from "./symbols";
-import { EntityDbMetadata } from "./EntityDbMetadata";
-
-/** Creates the placeholder file for our per-entity custom business logic in. */
-export function generateInitialEntityFile(meta: EntityDbMetadata): Code {
-  const entityName = meta.entity.name;
-  const codegenClass = imp(`${entityName}Codegen@./entities`);
-  return code`
-    export class ${entityName} extends ${codegenClass} {}
-  `;
-}