@autobe/compiler 0.3.23 → 0.4.0

package/src/AutoBeCompiler.ts

@@ -3,8 +3,6 @@ import {
   IAutoBeCompiler,
   IAutoBeInterfaceCompiler,
   IAutoBePrismaCompiler,
-  IAutoBePrismaCompilerProps,
-  IAutoBePrismaCompilerResult,
   IAutoBeTypeScriptCompiler,
   IAutoBeTypeScriptCompilerProps,
   IAutoBeTypeScriptCompilerResult,
@@ -15,27 +13,23 @@ import { AutoBePrismaCompiler } from "./AutoBePrismaCompiler";
 import { AutoBeTypeScriptCompiler } from "./AutoBeTypeScriptCompiler";
 
 export class AutoBeCompiler implements IAutoBeCompiler {
-  private readonly prisma_: IAutoBePrismaCompiler = new AutoBePrismaCompiler();
-  private readonly interface_: IAutoBeInterfaceCompiler =
-    new AutoBeInterfaceCompiler();
-  private readonly typescript_: IAutoBeTypeScriptCompiler =
-    new AutoBeTypeScriptCompiler();
-
-  public prisma(
-    props: IAutoBePrismaCompilerProps,
-  ): Promise<IAutoBePrismaCompilerResult> {
-    return this.prisma_.compile(props);
-  }
+  public readonly prisma: IAutoBePrismaCompiler = new AutoBePrismaCompiler();
 
   public interface(
     document: AutoBeOpenApi.IDocument,
   ): Promise<Record<string, string>> {
-    return this.interface_.compile(document);
+    return this.interface_compiler_.compile(document);
   }
 
   public typescript(
     props: IAutoBeTypeScriptCompilerProps,
   ): Promise<IAutoBeTypeScriptCompilerResult> {
-    return this.typescript_.compile(props);
+    return this.typescript_compiler_.compile(props);
   }
+
+  private readonly interface_compiler_: IAutoBeInterfaceCompiler =
+    new AutoBeInterfaceCompiler();
+
+  private readonly typescript_compiler_: IAutoBeTypeScriptCompiler =
+    new AutoBeTypeScriptCompiler();
 }

package/src/AutoBePrismaCompiler.ts

@@ -1,10 +1,15 @@
 import {
+  AutoBePrisma,
   IAutoBePrismaCompiler,
   IAutoBePrismaCompilerProps,
   IAutoBePrismaCompilerResult,
+  IAutoBePrismaValidation,
 } from "@autobe/interface";
 import { EmbedPrisma } from "embed-prisma";
 
+import { validatePrismaApplication } from "./prisma/validatePrismaApplication";
+import { writePrismaApplication } from "./prisma/writePrismaApplication";
+
 export class AutoBePrismaCompiler implements IAutoBePrismaCompiler {
   public async compile(
     props: IAutoBePrismaCompilerProps,
@@ -12,4 +17,16 @@ export class AutoBePrismaCompiler implements IAutoBePrismaCompiler {
     const compiler: EmbedPrisma = new EmbedPrisma();
     return compiler.compile(props.files);
   }
+
+  public async validate(
+    app: AutoBePrisma.IApplication,
+  ): Promise<IAutoBePrismaValidation> {
+    return validatePrismaApplication(app);
+  }
+
+  public async write(
+    app: AutoBePrisma.IApplication,
+  ): Promise<Record<string, string>> {
+    return writePrismaApplication(app);
+  }
 }

package/src/prisma/validatePrismaApplication.ts

@@ -0,0 +1,331 @@
+import { AutoBePrisma, IAutoBePrismaValidation } from "@autobe/interface";
+import { HashMap, hash } from "tstl";
+
+import { MapUtil } from "../utils/MapUtil";
+
+export function validatePrismaApplication(
+  application: AutoBePrisma.IApplication,
+): IAutoBePrismaValidation {
+  const dict: Map<string, AutoBePrisma.IModel> = new Map(
+    application.files
+      .map((file) => file.models)
+      .flat()
+      .map((model) => [model.name, model]),
+  );
+  const errors: IAutoBePrismaValidation.IError[] = [
+    ...validateDuplicatedFiles(application),
+    ...validateDuplicatedModels(application),
+    ...application.files
+      .map((file, fi) =>
+        file.models.map((model, mi) => {
+          const accessor: string = `application.files[${fi}].models[${mi}]`;
+          return [
+            ...validateDuplicatedFields(model, accessor),
+            ...validateDuplicatedIndexes(model, accessor),
+            ...validateIndexes(model, accessor),
+            ...validateReferences(model, accessor, dict),
+          ];
+        }),
+      )
+      .flat(2),
+  ];
+  return errors.length === 0
+    ? { success: true, data: application }
+    : { success: false, data: application, errors };
+}
+
+/* -----------------------------------------------------------
+  DUPLICATES
+----------------------------------------------------------- */
+function validateDuplicatedFiles(
+  app: AutoBePrisma.IApplication,
+): IAutoBePrismaValidation.IError[] {
+  interface IFileContainer {
+    file: AutoBePrisma.IFile;
+    index: number;
+  }
+  const group: Map<string, IFileContainer[]> = new Map();
+  app.files.forEach((file, fileIndex) => {
+    const container: IFileContainer = { file, index: fileIndex };
+    MapUtil.take(group, file.filename, () => []).push(container);
+  });
+
+  const errors: IAutoBePrismaValidation.IError[] = [];
+  for (const array of group.values())
+    if (array.length !== 1)
+      array.forEach((container, i) => {
+        errors.push({
+          path: `application.files[${container.index}]`,
+          table: null,
+          field: null,
+          message: [
+            `File ${container.file.filename} is duplicated.`,
+            "",
+            "Accessors of the other duplicated files are:",
+            "",
+            ...array
+              .filter((_oppo, j) => i !== j)
+              .map((oppo) => `- application.files[${oppo.index}]`),
+          ].join("\n"),
+        });
+      });
+  return errors;
+}
+
+function validateDuplicatedModels(
+  app: AutoBePrisma.IApplication,
+): IAutoBePrismaValidation.IError[] {
+  interface IModelContainer {
+    file: AutoBePrisma.IFile;
+    model: AutoBePrisma.IModel;
+    fileIndex: number;
+    modelIndex: number;
+  }
+  const modelContainers: Map<string, IModelContainer[]> = new Map();
+  app.files.forEach((file, fileIndex) => {
+    file.models.forEach((model, modelIndex) => {
+      const container: IModelContainer = {
+        file,
+        model,
+        fileIndex,
+        modelIndex,
+      };
+      MapUtil.take(modelContainers, model.name, () => []).push(container);
+    });
+  });
+
+  const errors: IAutoBePrismaValidation.IError[] = [];
+  for (const array of modelContainers.values())
+    if (array.length !== 1)
+      array.forEach((container, i) => {
+        errors.push({
+          path: `application.files[${container.fileIndex}].models[${container.modelIndex}]`,
+          table: container.model.name,
+          field: null,
+          message: [
+            `Model ${container.model.name} is duplicated.`,
+            "",
+            "Accessors of the other duplicated models are:",
+            "",
+            ...array
+              .filter((_oppo, j) => i !== j)
+              .map(
+                (oppo) =>
+                  `- application.files[${oppo.fileIndex}].models[${oppo.modelIndex}]`,
+              ),
+          ].join("\n"),
+        });
+      });
+  return errors;
+}
+
+function validateDuplicatedFields(
+  model: AutoBePrisma.IModel,
+  accessor: string,
+): IAutoBePrismaValidation.IError[] {
+  const group: Map<string, string[]> = new Map();
+  MapUtil.take(group, model.primaryField.name, () => []).push(
+    `${accessor}.primaryField.name`,
+  );
+  model.foreignFields.forEach((field, i) =>
+    MapUtil.take(group, field.name, () => []).push(
+      `${accessor}.foreignFields[${i}].name`,
+    ),
+  );
+  model.plainFields.forEach((field, i) =>
+    MapUtil.take(group, field.name, () => []).push(
+      `${accessor}.plainFields[${i}].name`,
+    ),
+  );
+
+  const errors: IAutoBePrismaValidation.IError[] = [];
+  for (const [field, array] of group)
+    if (array.length !== 1)
+      array.forEach((path, i) => {
+        errors.push({
+          path,
+          table: model.name,
+          field,
+          message: [
+            `Field ${field} is duplicated.`,
+            "",
+            "Accessors of the other duplicated fields are:",
+            "",
+            ...array.filter((_oppo, j) => i !== j).map((a) => `- ${a}`),
+          ].join("\n"),
+        });
+      });
+  return errors;
+}
+
+function validateDuplicatedIndexes(
+  model: AutoBePrisma.IModel,
+  accessor: string,
+): IAutoBePrismaValidation.IError[] {
+  const group: HashMap<string[], string[]> = new HashMap(
+    (x) => hash(...x),
+    (x, y) => x.length === y.length && x.every((v, i) => v === y[i]),
+  );
+  model.uniqueIndexes.forEach((unique, i) =>
+    group
+      .take(unique.fieldNames, () => [])
+      .push(`${accessor}.uniqueIndexes[${i}].fieldNames`),
+  );
+  model.plainIndexes.forEach((plain, i) =>
+    group
+      .take(plain.fieldNames, () => [])
+      .push(`${accessor}.plainIndexes[${i}].fieldNames`),
+  );
+
+  const errors: IAutoBePrismaValidation.IError[] = [];
+  for (const { first: fieldNames, second: array } of group)
+    if (array.length !== 1)
+      array.forEach((path, i) => {
+        errors.push({
+          path,
+          table: model.name,
+          field: null,
+          message: [
+            `Duplicated index found (${fieldNames.join(", ")})`,
+            "",
+            "Accessors of the other duplicated indexes are:",
+            "",
+            ...array.filter((_oppo, j) => i !== j).map((a) => `- ${a}`),
+          ].join("\n"),
+        });
+      });
+
+  if (
+    model.ginIndexes.length !==
+    new Set(model.ginIndexes.map((g) => g.fieldName)).size
+  )
+    errors.push({
+      path: `${accessor}.ginIndexes[].fieldName`,
+      table: model.name,
+      field: null,
+      message: [
+        "Duplicated GIN index found.",
+        "",
+        "GIN index can only be used once per field.",
+        "Please remove the duplicated GIN indexes.",
+      ].join("\n"),
+    });
+
+  return errors;
+}
+
+/* -----------------------------------------------------------
+  VALIDATIONS
+----------------------------------------------------------- */
+function validateIndexes(
+  model: AutoBePrisma.IModel,
+  accessor: string,
+): IAutoBePrismaValidation.IError[] {
+  // EMENSION
+  model.uniqueIndexes = model.uniqueIndexes.filter(
+    (unique) =>
+      unique.fieldNames.length !== 0 &&
+      unique.fieldNames[0] !== model.primaryField.name,
+  );
+  model.plainIndexes = model.plainIndexes.filter(
+    (plain) =>
+      plain.fieldNames.length !== 0 &&
+      plain.fieldNames[0] !== model.primaryField.name,
+  );
+
+  const errors: IAutoBePrismaValidation.IError[] = [];
+  const columnNames: Set<string> = new Set([
+    model.primaryField.name,
+    ...model.foreignFields.map((field) => field.name),
+    ...model.plainFields.map((field) => field.name),
+  ]);
+
+  // COLUMN LEVEL VALIDATION
+  const validate = <T>(props: {
+    title: string;
+    indexes: T[];
+    fieldNames: (idx: T) => string[];
+    accessor: (i: number, j: number) => string;
+    additional?: (idx: T, i: number) => void;
+  }) => {
+    props.indexes.forEach((idx, i) => {
+      // FIND TARGET FIELD
+      props.fieldNames(idx).forEach((name, j) => {
+        if (!columnNames.has(name))
+          errors.push({
+            path: `${accessor}.${props.accessor(i, j)}`,
+            table: model.name,
+            field: null,
+            message: `Field ${name} does not exist in model ${model.name}.`,
+          });
+      });
+    });
+  };
+  validate({
+    title: "unique index",
+    indexes: model.uniqueIndexes,
+    fieldNames: (idx) => idx.fieldNames,
+    accessor: (i, j) => `uniqueIndexes[${i}].fieldNames[${j}]`,
+  });
+  validate({
+    title: "index",
+    indexes: model.plainIndexes,
+    fieldNames: (idx) => idx.fieldNames,
+    accessor: (i, j) => `plainIndexes[${i}].fieldNames[${j}]`,
+  });
+  validate({
+    title: "index",
+    indexes: model.ginIndexes,
+    fieldNames: (idx) => [idx.fieldName],
+    accessor: (i) => `ginIndexes[${i}].fieldName`,
+    additional: (gin, i) => {
+      const pIndex: number = model.plainFields.findIndex(
+        (plain) => plain.name === gin.fieldName,
+      );
+      if (pIndex === -1)
+        errors.push({
+          path: `${accessor}.ginIndexes[${i}].fieldName`,
+          table: model.name,
+          field: null,
+          message: [
+            "GIN index can only be used on string typed field.",
+            `However, the target field ${gin.fieldName} does not exist",
+            "in the {@link plainFields}.`,
+          ].join("\n"),
+        });
+      else if (model.plainFields[pIndex].type !== "string")
+        errors.push({
+          path: `${accessor}.ginIndexes[${i}].fieldName`,
+          table: model.name,
+          field: model.plainFields[pIndex].name,
+          message: [
+            "GIN index can only be used on string typed field.",
+            `However, the target field ${gin.fieldName} is not string,`,
+            `but ${model.plainFields[pIndex].type}.`,
+            "",
+            `- accessor of the wrong typed field: ${`${accessor}.plainFields[${pIndex}].type`}`,
+          ].join("\n"),
+        });
+    },
+  });
+  return errors;
+}
+
+function validateReferences(
+  model: AutoBePrisma.IModel,
+  accessor: string,
+  dict: Map<string, AutoBePrisma.IModel>,
+): IAutoBePrismaValidation.IError[] {
+  const errors: IAutoBePrismaValidation.IError[] = [];
+  model.foreignFields.forEach((field, i) => {
+    const target = dict.get(field.relation.targetModel);
+    if (target === undefined)
+      errors.push({
+        path: `${accessor}.foreignFields[${i}].relation.targetModel`,
+        table: model.name,
+        field: field.name,
+        message: `Target model ${field.relation.targetModel} does not exist.`,
+      });
+  });
+  return errors;
+}

package/src/prisma/writePrismaApplication.ts

@@ -0,0 +1,250 @@
+import { AutoBePrisma } from "@autobe/interface";
+
+import { ArrayUtil } from "../utils/ArrayUtil";
+import { MapUtil } from "../utils/MapUtil";
+
+export function writePrismaApplication(
+  app: AutoBePrisma.IApplication,
+): Record<string, string> {
+  for (const file of app.files)
+    for (const model of file.models) fillMappingName(model);
+  return {
+    ...Object.fromEntries(
+      app.files
+        .filter((file) => file.filename !== "main.prisma")
+        .map((file) => [file.filename, writeFile(app, file)]),
+    ),
+    "main.prisma": MAIN_FILE,
+  };
+}
+
+function writeFile(
+  app: AutoBePrisma.IApplication,
+  file: AutoBePrisma.IFile,
+): string {
+  return file.models.map((model) => writeModel(app, file, model)).join("\n\n");
+}
+
+function writeModel(
+  app: AutoBePrisma.IApplication,
+  file: AutoBePrisma.IFile,
+  model: AutoBePrisma.IModel,
+): string {
+  return [
+    writeComment(
+      [
+        model.description,
+        "",
+        ...(model.material ? [] : [`@namespace ${file.namespace}`]),
+        "@author AutoBE - https://github.com/wrtnlabs/autobe",
+      ].join("\n"),
+    ),
+    `model ${model.name} {`,
+    indent(
+      ArrayUtil.paddle([writeColumns(model), writeRelations(app, model)]).join(
+        "\n",
+      ),
+    ),
+    "}",
+  ].join("\n");
+}
+
+function fillMappingName(model: AutoBePrisma.IModel): void {
+  const group: Map<string, AutoBePrisma.IForeignField[]> = new Map();
+  for (const ff of model.foreignFields) {
+    MapUtil.take(group, ff.relation.targetModel, () => []).push(ff);
+    if (ff.relation.targetModel == model.name)
+      ff.relation.mappingName = "recursive";
+  }
+  for (const array of group.values())
+    if (array.length !== 1)
+      for (const ff of array) {
+        ff.relation.mappingName = `${model.name}_of_${ff.name}`;
+      }
+}
+
+/* -----------------------------------------------------------
+  COLUMNS
+----------------------------------------------------------- */
+function writeColumns(model: AutoBePrisma.IModel): string[] {
+  return [
+    "//----",
+    "// COLUMNS",
+    "//----",
+    writePrimary(model.primaryField),
+    ...model.foreignFields.map((x) => ["", writeField(x)]).flat(),
+    ...model.plainFields.map((x) => ["", writeField(x)]).flat(),
+  ];
+}
+
+function writePrimary(field: AutoBePrisma.IPrimaryField): string {
+  return [
+    writeComment(field.description),
+    `${field.name} String @id @db.Uuid`,
+  ].join("\n");
+}
+
+function writeField(field: AutoBePrisma.IPlainField): string {
+  const logical: string = LOGICAL_TYPES[field.type];
+  const physical: string | undefined =
+    PHYSICAL_TYPES[field.type as keyof typeof PHYSICAL_TYPES];
+  return [
+    writeComment(field.description),
+    [
+      field.name,
+      `${logical}${field.nullable ? "?" : ""}`,
+      ...(physical ? [physical] : []),
+    ].join(" "),
+  ].join("\n");
+}
+
+/* -----------------------------------------------------------
+  RELATIONS
+----------------------------------------------------------- */
+function writeRelations(
+  app: AutoBePrisma.IApplication,
+  model: AutoBePrisma.IModel,
+): string[] {
+  interface IHasRelationship {
+    modelName: string;
+    unique: boolean;
+    mappingName?: string;
+  }
+  const hasRelationships: IHasRelationship[] = app.files
+    .map((otherFile) =>
+      otherFile.models.map((otherModel) =>
+        otherModel.foreignFields
+          .filter(
+            (otherForeign) => otherForeign.relation.targetModel === model.name,
+          )
+          .map((otherForeign) => ({
+            modelName: otherModel.name,
+            unique: otherForeign.unique,
+            mappingName: otherForeign.relation.mappingName,
+          })),
+      ),
+    )
+    .flat(2);
+  const foreignIndexes: AutoBePrisma.IForeignField[] =
+    model.foreignFields.filter(
+      (f) =>
+        model.uniqueIndexes.every((u) => u.fieldNames[0] !== f.name) &&
+        model.plainIndexes.every((p) => p.fieldNames[0] !== f.name),
+    );
+  const contents: string[][] = [
+    model.foreignFields.map(writeConstraint),
+    hasRelationships.map((r) =>
+      [
+        r.mappingName ?? r.modelName,
+        `${r.modelName}${r.unique ? "?" : "[]"}`,
+        ...(r.mappingName ? [`@relation("${r.mappingName}")`] : []),
+      ].join(" "),
+    ),
+    foreignIndexes.map(writeForeignIndex),
+    [
+      ...model.uniqueIndexes.map(writeUniqueIndex),
+      ...model.plainIndexes.map(writePlainIndex),
+      ...model.ginIndexes.map(writeGinIndex),
+    ],
+  ];
+  if (contents.every((c) => c.length === 0)) return [];
+  return [
+    "//----",
+    "// RELATIONS",
+    "//----",
+    // paddled content
+    ...ArrayUtil.paddle(contents),
+  ];
+}
+
+function writeConstraint(field: AutoBePrisma.IForeignField): string {
+  return [
+    field.relation.name,
+    `${field.relation.targetModel}${field.nullable ? "?" : ""}`,
+    `@relation(${[
+      ...(field.relation.mappingName
+        ? [`"${field.relation.mappingName}"`]
+        : []),
+      `fields: [${field.name}]`,
+      `references: [id]`,
+      `onDelete: Cascade`,
+    ].join(", ")})`,
+  ].join(" ");
+}
+
+function writeForeignIndex(field: AutoBePrisma.IForeignField): string {
+  return `@@${field.unique ? "unique" : "index"}([${field.name}])`;
+}
+
+function writeUniqueIndex(field: AutoBePrisma.IUniqueIndex): string {
+  return `@@unique([${field.fieldNames.join(", ")}])`;
+}
+
+function writePlainIndex(field: AutoBePrisma.IPlainIndex): string {
+  return `@@index([${field.fieldNames.join(", ")}])`;
+}
+
+function writeGinIndex(field: AutoBePrisma.IGinIndex): string {
+  return `@@index([${field.fieldName}(ops: raw("gin_trgm_ops"))], type: Gin)`;
+}
+
+/* -----------------------------------------------------------
+  BACKGROUND
+----------------------------------------------------------- */
+function writeComment(content: string): string {
+  return content
+    .split("\r\n")
+    .join("\n")
+    .split("\n")
+    .map((str) => `///${str.length ? ` ${str}` : ""}`)
+    .join("\n")
+    .trim();
+}
+
+function indent(content: string): string {
+  return content
+    .split("\r\n")
+    .join("\n")
+    .split("\n")
+    .map((str) => `  ${str}`)
+    .join("\n");
+}
+
+const LOGICAL_TYPES = {
+  // native types
+  boolean: "Boolean",
+  int: "Int",
+  double: "Float",
+  string: "String",
+  // formats
+  datetime: "DateTime",
+  uuid: "String",
+  uri: "String",
+};
+
+const PHYSICAL_TYPES = {
+  int: "@db.Integer",
+  double: "@db.DoublePrecision",
+  uuid: "@db.Uuid",
+  datetime: "@db.Timestamptz",
+  uri: "@db.VarChar(80000)",
+};
+
+const MAIN_FILE = `
+generator client {
+  provider        = "prisma-client-js"
+  previewFeatures = ["postgresqlExtensions", "views"]
+  binaryTargets   = ["native"]
+}
+
+datasource db {
+  provider   = "postgresql"
+  url        = env("DATABASE_URL")
+  extensions = []
+}
+
+generator markdown {
+  provider = "prisma-markdown"
+  output   = "../docs/ERD.md"
+}
+`.trim();

package/src/utils/ArrayUtil.ts

@@ -8,4 +8,14 @@ export namespace ArrayUtil {
       result[i] = await callback(array[i], i, array);
     return result;
   }
+
+  export function paddle(contents: string[][]): string[] {
+    const output: string[] = [];
+    contents.forEach((c) => {
+      if (c.length === 0) return;
+      else if (output.length === 0) output.push(...c);
+      else output.push("", ...c);
+    });
+    return output;
+  }
 }

package/src/utils/MapUtil.ts

@@ -0,0 +1,10 @@
+export namespace MapUtil {
+  export function take<K, V>(map: Map<K, V>, key: K, value: () => V): V {
+    if (map.has(key)) {
+      return map.get(key) as V;
+    }
+    const newValue = value();
+    map.set(key, newValue);
+    return newValue;
+  }
+}