joist-codegen 0.1.538 → 1.0.0

package/src/generateMetadataFile.ts

@@ -1,175 +0,0 @@
-import { code, Code, imp } from "ts-poet";
-import { Config } from "./config";
-import { EntityDbMetadata } from "./EntityDbMetadata";
-import { EntityMetadata, EnumFieldSerde, ForeignKeySerde, PrimaryKeySerde, SimpleSerde } from "./symbols";
-
-export function generateMetadataFile(config: Config, dbMetadata: EntityDbMetadata): Code {
-  const { entity } = dbMetadata;
-
-  const { primaryKey, primitives, enums, m2o } = generateColumns(dbMetadata);
-  const { primaryKeyField, primitiveFields, enumFields, m2oFields, o2mFields, m2mFields, o2oFields } = generateFields(
-    config,
-    dbMetadata,
-  );
-
-  return code`
-    export const ${entity.metaName}: ${EntityMetadata}<${entity.type}> = {
-      cstr: ${entity.type},
-      type: "${entity.name}",
-      tagName: "${config.entities[entity.name].tag}",
-      tableName: "${dbMetadata.tableName}",
-      columns: [ ${primaryKey} ${enums} ${primitives} ${m2o} ],
-      fields: [ ${primaryKeyField} ${enumFields} ${primitiveFields} ${m2oFields} ${o2mFields} ${m2mFields} ${o2oFields} ],
-      config: ${entity.configConst},
-      factory: ${imp(`new${entity.name}@./entities`)},
-    };
-
-    (${entity.name} as any).metadata = ${entity.metaName};
-  `;
-}
-
-function generateColumns(
-  dbMetadata: EntityDbMetadata,
-): { primaryKey: Code; primitives: Code[]; enums: Code[]; m2o: Code[] } {
-  const primaryKey = code`
-    { fieldName: "id", columnName: "id", dbType: "int", serde: new ${PrimaryKeySerde}(() => ${dbMetadata.entity.metaName}, "id", "id") },
-  `;
-
-  const primitives = dbMetadata.primitives.map((p) => {
-    const { fieldName, columnName, columnType } = p;
-    return code`
-      {
-        fieldName: "${fieldName}",
-        columnName: "${columnName}",
-        dbType: "${columnType}",
-        serde: new ${SimpleSerde}("${fieldName}", "${columnName}"),
-      },`;
-  });
-
-  const enums = dbMetadata.enums.map((e) => {
-    const { fieldName, columnName, enumDetailType } = e;
-    return code`
-      {
-        fieldName: "${fieldName}",
-        columnName: "${columnName}",
-        dbType: "int",
-        serde: new ${EnumFieldSerde}("${fieldName}", "${columnName}", ${enumDetailType}),
-      },
-    `;
-  });
-
-  const m2o = dbMetadata.manyToOnes.map((m2o) => {
-    const { fieldName, columnName, otherEntity } = m2o;
-    return code`
-      {
-        fieldName: "${fieldName}",
-        columnName: "${columnName}",
-        dbType: "int",
-        serde: new ${ForeignKeySerde}("${fieldName}", "${columnName}", () => ${otherEntity.metaName}),
-      },
-    `;
-  });
-
-  return { primaryKey, primitives, enums, m2o };
-}
-
-function generateFields(
-  config: Config,
-  dbMetadata: EntityDbMetadata,
-): {
-  primaryKeyField: Code;
-  primitiveFields: Code[];
-  enumFields: Code[];
-  m2oFields: Code[];
-  o2mFields: Code[];
-  m2mFields: Code[];
-  o2oFields: Code[];
-} {
-  const primaryKeyField = code`
-    { kind: "primaryKey", fieldName: "id", fieldIdName: undefined, required: true },
-  `;
-
-  const primitiveFields = dbMetadata.primitives.map((p) => {
-    const { fieldName, derived } = p;
-    return code`
-      {
-        kind: "primitive",
-        fieldName: "${fieldName}",
-        fieldIdName: undefined,
-        derived: ${!derived ? false : `"${derived}"`},
-        required: ${!derived && p.notNull},
-        protected: ${p.protected},
-        type: ${typeof p.fieldType === "string" ? `"${p.fieldType}"` : p.fieldType},
-      },`;
-  });
-
-  const enumFields = dbMetadata.enums.map(({ fieldName, enumDetailType, notNull }) => {
-    return code`
-      {
-        kind: "enum",
-        fieldName: "${fieldName}",
-        fieldIdName: undefined,
-        required: ${notNull},
-        enumDetailType: ${enumDetailType},
-      },
-    `;
-  });
-
-  const m2oFields = dbMetadata.manyToOnes.map((m2o) => {
-    const { fieldName, notNull, otherEntity, otherFieldName } = m2o;
-    return code`
-      {
-        kind: "m2o",
-        fieldName: "${fieldName}",
-        fieldIdName: "${fieldName}Id",
-        required: ${notNull},
-        otherMetadata: () => ${otherEntity.metaName},
-        otherFieldName: "${otherFieldName}",
-      },
-    `;
-  });
-
-  const o2mFields = dbMetadata.oneToManys.map((m2o) => {
-    const { fieldName, singularName, otherEntity, otherFieldName } = m2o;
-    return code`
-      {
-        kind: "o2m",
-        fieldName: "${fieldName}",
-        fieldIdName: "${singularName}Ids",
-        required: false,
-        otherMetadata: () => ${otherEntity.metaName},
-        otherFieldName: "${otherFieldName}",
-      },
-    `;
-  });
-
-  const m2mFields = dbMetadata.manyToManys.map((m2o) => {
-    const { fieldName, singularName, otherEntity, otherFieldName } = m2o;
-    return code`
-      {
-        kind: "m2m",
-        fieldName: "${fieldName}",
-        fieldIdName: "${singularName}Ids",
-        required: false,
-        otherMetadata: () => ${otherEntity.metaName},
-        otherFieldName: "${otherFieldName}",
-      },
-    `;
-  });
-
-  const o2oFields = dbMetadata.oneToOnes.map((o2o) => {
-    const { fieldName, otherEntity, otherFieldName } = o2o;
-    return code`
-      {
-        kind: "o2o",
-        fieldName: "${fieldName}",
-        fieldIdName: "${fieldName}Id",
-        required: false,
-        otherMetadata: () => ${otherEntity.metaName},
-        otherFieldName: "${otherFieldName}",
-      },
-    `;
-  });
-
-  return { primaryKeyField, primitiveFields, enumFields, m2oFields, o2mFields, m2mFields, o2oFields };
-}

package/src/index.ts

@@ -1,180 +0,0 @@
-import { promises as fs } from "fs";
-import { newPgConnectionConfig } from "joist-utils";
-import { Client } from "pg";
-import pgStructure, { Db, Table } from "pg-structure";
-import { code, Code, def, imp } from "ts-poet";
-import { assignTags } from "./assignTags";
-import { Config, loadConfig, writeConfig } from "./config";
-import { EntityDbMetadata } from "./EntityDbMetadata";
-import { generateEntitiesFile } from "./generateEntitiesFile";
-import { generateEntityCodegenFile } from "./generateEntityCodegenFile";
-import { generateEnumFile } from "./generateEnumFile";
-import { generateFactoriesFiles } from "./generateFactoriesFiles";
-import { generateInitialEntityFile } from "./generateInitialEntityFile";
-import { generateMetadataFile } from "./generateMetadataFile";
-import { configureMetadata, EntityManager } from "./symbols";
-import { isEntityTable, isEnumTable, merge, tableToEntityName, trueIfResolved } from "./utils";
-
-export { EntityDbMetadata };
-export {
-  PrimitiveField,
-  EnumField,
-  ManyToOneField,
-  OneToManyField,
-  ManyToManyField,
-  OneToOneField,
-  makeEntity,
-} from "./EntityDbMetadata";
-
-export interface CodeGenFile {
-  name: string;
-  contents: Code | string;
-  overwrite: boolean;
-}
-
-/** A map from Enum table name to the rows currently in the table. */
-export type EnumRows = Record<string, EnumRow[]>;
-export type EnumRow = { id: number; code: string; name: string };
-
-/** Uses entities and enums from the `db` schema and saves them into our entities directory. */
-export async function generateAndSaveFiles(config: Config, dbMeta: DbMetadata): Promise<void> {
-  const files = await generateFiles(config, dbMeta);
-  await fs.mkdir(config.entitiesDirectory, { recursive: true });
-  for await (const file of files) {
-    const path = `${config.entitiesDirectory}/${file.name}`;
-    if (file.overwrite) {
-      await fs.writeFile(path, await contentToString(file.contents, file.name));
-    } else {
-      const exists = await trueIfResolved(fs.access(path));
-      if (!exists) {
-        await fs.writeFile(path, await contentToString(file.contents, file.name));
-      }
-    }
-  }
-}
-
-/** Generates our `${Entity}` and `${Entity}Codegen` files based on the `db` schema. */
-export async function generateFiles(config: Config, dbMeta: DbMetadata): Promise<CodeGenFile[]> {
-  const { entities, enumTables: enums, enumRows } = dbMeta;
-  const entityFiles = entities
-    .map((meta) => {
-      const entityName = meta.entity.name;
-      return [
-        {
-          name: `${entityName}Codegen.ts`,
-          contents: generateEntityCodegenFile(config, meta),
-          overwrite: true,
-        },
-        { name: `${entityName}.ts`, contents: generateInitialEntityFile(meta), overwrite: false },
-      ];
-    })
-    .reduce(merge, []);
-
-  const enumFiles = enums
-    .map((table) => {
-      const enumName = tableToEntityName(config, table);
-      return [
-        {
-          name: `${enumName}.ts`,
-          contents: generateEnumFile(config, table, enumRows, enumName),
-          overwrite: true,
-        },
-      ];
-    })
-    .reduce(merge, []);
-
-  const contextType = config.contextType ? imp(config.contextType) : "{}";
-
-  const metadataFile: CodeGenFile = {
-    name: "./metadata.ts",
-    contents: code`
-      export class ${def("EntityManager")} extends ${EntityManager}<${contextType}> {}
-
-      ${entities.map((meta) => generateMetadataFile(config, meta))}
-
-      const allMetadata = [${entities.map((meta) => meta.entity.metaName).join(", ")}];
-      ${configureMetadata}(allMetadata);
-    `,
-    overwrite: true,
-  };
-
-  const entitiesFile: CodeGenFile = {
-    name: "./entities.ts",
-    contents: generateEntitiesFile(config, entities, enums),
-    overwrite: true,
-  };
-
-  const factoriesFiles: CodeGenFile[] = generateFactoriesFiles(entities);
-
-  const indexFile: CodeGenFile = {
-    name: "./index.ts",
-    contents: code`export * from "./entities"`,
-    overwrite: false,
-  };
-
-  // Look for modules to require and call the exported `.run(EntityDbMetadata[], Table[])` method
-
-  const pluginFiles: CodeGenFile[] = (
-    await Promise.all(
-      config.codegenPlugins.map((p) => {
-        const plugin = require(p);
-        return plugin.run(entities, enumRows);
-      }),
-    )
-  ).flat();
-
-  return [...entityFiles, ...enumFiles, entitiesFile, ...factoriesFiles, metadataFile, indexFile, ...pluginFiles];
-}
-
-export async function loadEnumRows(db: Db, client: Client): Promise<EnumRows> {
-  const promises = db.tables.filter(isEnumTable).map(async (table) => {
-    const result = await client.query(`SELECT * FROM ${table.name} ORDER BY id`);
-    const rows = result.rows.map((row) => row as EnumRow);
-    return [table.name, rows] as [string, EnumRow[]];
-  });
-  return Object.fromEntries(await Promise.all(promises));
-}
-
-export async function contentToString(content: Code | string, fileName: string): Promise<string> {
-  if (typeof content === "string") {
-    return content;
-  }
-  return await content.toStringWithImports(fileName);
-}
-
-if (require.main === module) {
-  if (Object.fromEntries === undefined) {
-    throw new Error("Joist requires Node v12.4.0+");
-  }
-  (async function () {
-    const pgConfig = newPgConnectionConfig();
-    const db = await pgStructure(pgConfig);
-
-    const client = new Client(pgConfig);
-    await client.connect();
-    const enumRows = await loadEnumRows(db, client);
-    await client.end();
-
-    const config = await loadConfig();
-
-    const entityTables = db.tables.filter(isEntityTable).sortBy("name");
-    const enumTables = db.tables.filter(isEnumTable).sortBy("name");
-    const entities = entityTables.map((table) => new EntityDbMetadata(config, table));
-    const dbMetadata: DbMetadata = { entityTables, enumTables, entities, enumRows };
-
-    assignTags(config, dbMetadata);
-    await writeConfig(config);
-
-    await generateAndSaveFiles(config, dbMetadata);
-  })().catch((err) => {
-    console.error(err);
-    process.exit(1);
-  });
-}
-
-export interface DbMetadata {
-  entityTables: Table[];
-  enumTables: Table[];
-  entities: EntityDbMetadata[];
-  enumRows: EnumRows;
-}

package/src/symbols.ts

@@ -1,53 +0,0 @@
-import { imp } from "ts-poet";
-
-export const ConfigApi = imp("ConfigApi@joist-orm");
-export const FieldStatus = imp("FieldStatus@joist-orm");
-export const Entity = imp("Entity@joist-orm");
-export const BaseEntity = imp("BaseEntity@joist-orm");
-export const Flavor = imp("Flavor@joist-orm");
-export const Reference = imp("Reference@joist-orm");
-export const Collection = imp("Collection@joist-orm");
-export const OneToManyCollection = imp("OneToManyCollection@joist-orm");
-export const EntityOrmField = imp("EntityOrmField@joist-orm");
-export const EntityManager = imp("EntityManager@joist-orm");
-export const EntityMetadata = imp("EntityMetadata@joist-orm");
-export const Lens = imp("Lens@joist-orm");
-export const PrimaryKeySerde = imp("PrimaryKeySerde@joist-orm");
-export const ManyToOneReference = imp("ManyToOneReference@joist-orm");
-export const OneToOneReference = imp("OneToOneReference@joist-orm");
-export const ManyToManyCollection = imp("ManyToManyCollection@joist-orm");
-export const EnumFieldSerde = imp("EnumFieldSerde@joist-orm");
-export const ForeignKeySerde = imp("ForeignKeySerde@joist-orm");
-export const SimpleSerde = imp("SimpleSerde@joist-orm");
-export const fail = imp("fail@joist-orm");
-export const setOpts = imp("setOpts@joist-orm");
-export const setField = imp("setField@joist-orm");
-export const OrderBy = imp("OrderBy@joist-orm");
-export const OptsOf = imp("OptsOf@joist-orm");
-export const IdOf = imp("IdOf@joist-orm");
-export const PartialOrNull = imp("PartialOrNull@joist-orm");
-export const BooleanFilter = imp("BooleanFilter@joist-orm");
-export const ValueFilter = imp("ValueFilter@joist-orm");
-export const EntityFilter = imp("EntityFilter@joist-orm");
-export const BooleanGraphQLFilter = imp("BooleanGraphQLFilter@joist-orm");
-export const EntityGraphQLFilter = imp("EntityGraphQLFilter@joist-orm");
-export const EnumGraphQLFilter = imp("EnumGraphQLFilter@joist-orm");
-export const ValueGraphQLFilter = imp("ValueGraphQLFilter@joist-orm");
-export const FilterOf = imp("FilterOf@joist-orm");
-export const GraphQLFilterOf = imp("GraphQLFilterOf@joist-orm");
-export const configureMetadata = imp("configureMetadata@joist-orm");
-export const newRequiredRule = imp("newRequiredRule@joist-orm");
-export const Changes = imp("Changes@joist-orm");
-export const newChangesProxy = imp("newChangesProxy@joist-orm");
-export const LoadHint = imp("LoadHint@joist-orm");
-export const Loaded = imp("Loaded@joist-orm");
-export const getEm = imp("getEm@joist-orm");
-export const loadLens = imp("loadLens@joist-orm");
-export const hasOneThrough = imp("hasOneThrough@joist-orm");
-export const hasMany = imp("hasMany@joist-orm");
-export const hasOne = imp("hasOne@joist-orm");
-export const hasOneToOne = imp("hasOneToOne@joist-orm");
-export const hasManyToMany = imp("hasManyToMany@joist-orm");
-export const newTestInstance = imp("newTestInstance@joist-orm");
-export const New = imp("New@joist-orm");
-export const FactoryOpts = imp("FactoryOpts@joist-orm");

package/src/utils.ts

@@ -1,88 +0,0 @@
-import isPlainObject from "is-plain-object";
-import { Config } from "./config";
-import { Table } from "pg-structure";
-import pluralize from "pluralize";
-import { pascalCase } from "change-case";
-
-export function isEntityTable(t: Table): boolean {
-  const columnNames = t.columns.map((c) => c.name);
-  return includesAllOf(columnNames, ["id", "created_at", "updated_at"]);
-}
-
-export function isEnumTable(t: Table): boolean {
-  const columnNames = t.columns.map((c) => c.name);
-  return includesAllOf(columnNames, ["id", "code", "name"]) && !isEntityTable(t);
-}
-
-export function isJoinTable(t: Table): boolean {
-  const { columns } = t;
-  const hasOnePk = columns.filter((c) => c.isPrimaryKey).length === 1;
-  const hasTwoFks = columns.filter((c) => c.isForeignKey).length === 2;
-  const hasThreeColumns = columns.length === 3;
-  const hasFourColumnsOneIsCreatedAt =
-    columns.length === 4 && columns.filter((c) => c.name === "created_at").length === 1;
-  return hasOnePk && hasTwoFks && (hasThreeColumns || hasFourColumnsOneIsCreatedAt);
-}
-
-function includesAllOf(set: string[], subset: string[]): boolean {
-  return subset.find((e) => !set.includes(e)) === undefined;
-}
-
-/** Converts `projects` to `Project`. */
-export function tableToEntityName(config: Config, table: Table): string {
-  let entityName = config.__tableToEntityName[table.name];
-  if (!entityName) {
-    const configEntityName = Object.entries(config.entities)
-      .filter(([, conf]) => conf.tableName === table.name)
-      .map(([entityName]) => entityName)[0];
-    entityName = configEntityName || pascalCase(pluralize.singular(table.name));
-    config.__tableToEntityName[table.name] = entityName;
-  }
-  return entityName;
-}
-
-/** Maps db types, i.e. `int`, to JS types, i.e. `number`. */
-export function mapSimpleDbType(dbType: string): string {
-  switch (dbType) {
-    case "bool":
-      return "boolean";
-    case "int":
-    case "numeric":
-      return "number";
-    case "text":
-    case "varchar":
-      return "string";
-    case "timestamptz":
-    case "date":
-      return "Date";
-    default:
-      throw new Error(`Unrecognized type ${dbType}`);
-  }
-}
-
-export function merge<T>(a: T[], b: T[]): T[] {
-  return [...a, ...b];
-}
-
-/** Returns true if `p` is resolved, otherwise false if it is rejected. */
-export async function trueIfResolved(p: Promise<unknown>): Promise<boolean> {
-  return p.then(
-    () => true,
-    () => false,
-  );
-}
-
-export function fail(message?: string): never {
-  throw new Error(message || "Failed");
-}
-
-export function sortKeys<T extends object>(o: T): T {
-  return Object.keys(o)
-    .sort()
-    .reduce((acc, key) => {
-      const value = o[key as keyof T];
-      const newValue = typeof value === "object" && isPlainObject(value) ? sortKeys((value as any) as object) : value;
-      acc[key as keyof T] = newValue as any;
-      return acc;
-    }, ({} as any) as T);
-}

package/tsconfig.json

@@ -1,21 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "es2019",
-    "module": "commonjs",
-    "lib": ["es2019"],
-    "strict": true,
-    "noImplicitReturns": true,
-    "types": ["jest", "node"],
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "composite": true,
-    "sourceMap": true,
-    "outDir": "./build",
-    "rootDir": "./src",
-    "baseUrl": "./src",
-    "paths": {
-      "joist-utils": ["../../utils/src"]
-    }
-  },
-  "references": [{ "path": "../utils" }]
-}