@snowtop/ent 0.1.0-alpha160-test4 → 0.1.0-alpha160-test6

package/src/tsc/move_generated.ts

@@ -0,0 +1,191 @@
+import * as glob from "glob";
+import * as path from "path";
+import * as fs from "fs";
+import ts from "typescript";
+import {
+  isRelativeGeneratedImport,
+  isRelativeImport,
+  isSrcGeneratedImport,
+  updateImportPath,
+} from "./ast";
+import { transform, TransformFile } from "./transform";
+
+class MoveFiles {
+  constructor(private globPath: string) {}
+
+  move() {
+    const files = glob.sync(this.globPath);
+    moveFiles(files);
+  }
+}
+
+class TransformImports implements TransformFile {
+  cwd: string;
+  constructor(
+    public glob: string,
+    public prettierGlob: string,
+    private relativeImports: boolean,
+    private checkRelativeImportsValid?: boolean,
+  ) {
+    this.cwd = process.cwd();
+  }
+
+  globOptions = {
+    ignore: ["node_modules/**"],
+  };
+
+  traverseChild(
+    sourceFile: ts.SourceFile,
+    contents: string,
+    file: string,
+    node: ts.Node,
+  ) {
+    if (!ts.isImportDeclaration(node)) {
+      return { node };
+    }
+    let dirPath = path.join(this.cwd, file, "..");
+
+    const newImportPath = this.getNewImportPath(
+      node,
+      file,
+      sourceFile,
+      dirPath,
+    );
+    if (!newImportPath) {
+      return { node };
+    }
+
+    const v = updateImportPath(contents, node, sourceFile, newImportPath);
+
+    return {
+      traversed: true,
+      rawString: v,
+    };
+  }
+
+  getNewImportPath(
+    node: ts.ImportDeclaration,
+    file: string,
+    sourceFile: ts.SourceFile,
+    dirPath: string,
+  ) {
+    const text = node.moduleSpecifier.getText(sourceFile).slice(1, -1);
+
+    // it's relative and has generated in there, continue
+    // do relative imports path regardless of if relative imports is on or not
+    if (isRelativeGeneratedImport(node, sourceFile)) {
+      const oldPath = path.join(dirPath, text);
+      const relFromRoot = path.relative(".", oldPath);
+      const conv = transformPath(relFromRoot);
+      if (!conv || conv.newFile === relFromRoot) {
+        return;
+      }
+      return path.relative(dirPath, conv.newFile);
+    }
+
+    if (this.checkRelativeImportsValid && isRelativeImport(node, sourceFile)) {
+      const parts = file.split(path.sep);
+      if (
+        parts.length === 5 &&
+        parts.slice(0, 3).join(path.sep) ===
+          ["src", "graphql", "generated"].join(path.sep)
+      ) {
+        // we have custom graphql import paths
+        // src/graphql/generated/mutations|resolvers/foo_type.ts
+        // which used to be
+        // src/graphql/mutations|resolvers/generated/foo_type.ts
+
+        // we probably have a broken import.
+        // try and fix it...
+        let temp = parts[2];
+        parts[2] = parts[3];
+        parts[3] = temp;
+        const oldPath = parts.join(path.sep);
+
+        let oldDir = path.join(this.cwd, oldPath, "..");
+        let importPath = path.join(oldDir, text);
+        let exists = fs.statSync(importPath + ".ts", { throwIfNoEntry: false });
+        if (!exists) {
+          // doesn't exist. sadly has to be fixed manually. could theoretically also be a directory but we shouldn't have that
+          return;
+        }
+
+        return path.relative(dirPath, importPath);
+      }
+    }
+    // if relative imports, we done.
+    if (this.relativeImports) {
+      return;
+    }
+
+    // non relative, only transform src paths with generated
+    if (isSrcGeneratedImport(node, sourceFile)) {
+      const conv = transformPath(text);
+      if (!conv || conv.newFile === text) {
+        return;
+      }
+      return conv.newFile;
+    }
+
+    return;
+  }
+}
+
+function transformPath(old: string) {
+  const parts = old.split(path.sep);
+  if (parts.length < 3) {
+    return;
+  }
+
+  const changedParts = parts
+    .slice(0, 2)
+    .concat("generated")
+    .concat(parts.slice(2).filter((v) => v !== "generated"));
+
+  const newFile = changedParts.join(path.sep);
+
+  return { changedParts, newFile };
+}
+
+function moveFiles(files: string[]) {
+  files.forEach((file) => {
+    const conv = transformPath(file);
+    if (!conv) {
+      return;
+    }
+    const { changedParts, newFile } = conv;
+
+    if (file === newFile) {
+      return;
+    }
+
+    // check if directory exists, if not, create recursive dir
+    const p = changedParts.slice(0, changedParts.length - 1).join(path.sep);
+    const statInfo = fs.statSync(p, { throwIfNoEntry: false });
+    if (!statInfo) {
+      fs.mkdirSync(p, {
+        recursive: true,
+      });
+    }
+
+    // move file to new location
+    fs.renameSync(file, newFile);
+  });
+}
+
+export function moveGenerated(relativeImports: boolean) {
+  new MoveFiles("src/ent/**/generated/**/**.ts").move();
+  new MoveFiles("src/graphql/**/generated/**/**.ts").move();
+
+  transform(
+    new TransformImports("src/ent/**/*.ts", "src/ent/**/*.ts", relativeImports),
+  );
+  transform(
+    new TransformImports(
+      "src/graphql/**/*.ts",
+      "src/graphql/**/*.ts",
+      relativeImports,
+      true,
+    ),
+  );
+}

package/src/tsc/transform.ts

@@ -0,0 +1,226 @@
+import * as glob from "glob";
+import ts from "typescript";
+import { execSync } from "child_process";
+import * as fs from "fs";
+import { getImportInfo, transformImport } from "./ast";
+import { createSourceFile, getTargetFromCurrentDir } from "./compilerOptions";
+
+interface TraverseChildResponse {
+  // keep this node, nothing to do here
+  node?: ts.Node;
+
+  // main change we're doing here, transforming file
+  rawString?: string;
+
+  // if this is true, overwrite the file
+  traversed?: boolean;
+
+  // if set, these imports will be added for sure regardless of if path is there
+  imports?: Map<string, string[]>;
+
+  removeImports?: string[];
+
+  allowSeenImportsAdded?: boolean;
+}
+
+interface NodeInfo {
+  node?: ts.Node;
+  rawString?: string;
+}
+
+export interface TransformFile {
+  glob: string;
+
+  globOptions?: glob.GlobOptions;
+
+  preprocessFile?: (
+    contents: string,
+    file: string,
+    sourceFile: ts.SourceFile,
+  ) => boolean;
+
+  traverseChild(
+    sourceFile: ts.SourceFile,
+    contents: string,
+    file: string,
+    node: ts.Node,
+  ): TraverseChildResponse | undefined;
+
+  filter?(files: string[]): string[];
+
+  fileToWrite?(file: string): string;
+
+  postProcess?(file: string): void;
+
+  prettierGlob?: string;
+}
+
+function normalizePath(p: string) {
+  if (p.endsWith("..")) {
+    return p + "/";
+  }
+  return p;
+}
+
+export function transform(transform: TransformFile) {
+  let files = glob.sync(transform.glob, transform.globOptions ?? {});
+  const target = getTargetFromCurrentDir();
+  if (transform.filter) {
+    const f2 = files.map((f) => (typeof f === "string" ? f : f.path));
+    files = transform.filter(f2);
+  }
+
+  files.forEach((file) => {
+    let { contents, sourceFile } = createSourceFile(target, file);
+
+    let nodes: NodeInfo[] = [];
+
+    let imports: Map<string, string[]> = new Map();
+    let removeImports: string[] = [];
+    let traversed = false;
+    let allowSeenImportsAdded = false;
+
+    let seenImports: Map<string, boolean> = new Map();
+    ts.forEachChild(sourceFile, function (node: ts.Node) {
+      if (ts.isImportDeclaration(node)) {
+        const imp = getImportInfo(node, sourceFile);
+        if (imp) {
+          imp.imports.forEach((v) => {
+            v = v.trim();
+            v && seenImports.set(v, true);
+          });
+        }
+      }
+      const ret = transform.traverseChild(sourceFile, contents, file, node);
+      if (!ret) {
+        return;
+      }
+      if (ret.node || ret.rawString) {
+        nodes.push(ret);
+      }
+
+      if (ret.imports) {
+        for (const [k, v] of ret.imports) {
+          imports.set(k, v);
+        }
+      }
+      if (ret.traversed) {
+        traversed = ret.traversed;
+      }
+
+      if (ret.removeImports?.length) {
+        removeImports.push(...ret.removeImports);
+      }
+
+      if (ret.allowSeenImportsAdded) {
+        allowSeenImportsAdded = ret.allowSeenImportsAdded;
+      }
+    });
+
+    if (!traversed) {
+      return;
+    }
+
+    let newContents = "";
+    let afterProcessed = false;
+
+    let seen = new Map<string, boolean>();
+
+    const processAfterImport = () => {
+      // do this for the first non-import node we see
+      // we want to add new imports to end of imports and there's an assumption that imports are ordered
+      // at top of file
+
+      // TODO account for placement after first comment
+      if (!afterProcessed) {
+        for (const [imp, list] of imports) {
+          if (seen.has(imp)) {
+            continue;
+          }
+          // this says only add things you haven't seen
+          // we want to add something we've seen in this case
+          let final = list;
+          if (!allowSeenImportsAdded) {
+            final = list.filter((v) => !seenImports.has(v));
+          }
+          if (final.length) {
+            newContents += `\nimport { ${final.join(", ")} } from "${imp}";\n`;
+          }
+        }
+        afterProcessed = true;
+      }
+    };
+
+    for (const node of nodes) {
+      if (node.node) {
+        if (ts.isImportDeclaration(node.node)) {
+          const impInfo = getImportInfo(node.node, sourceFile);
+          //          console.debug(impInfo);
+          if (impInfo) {
+            const impPath = normalizePath(impInfo.importPath);
+
+            const list = imports.get(impPath);
+            // path exists, we care about it
+            if (list !== undefined) {
+              let transformed = transformImport(
+                contents,
+                node.node,
+                sourceFile,
+                {
+                  // if we've done this path before, don't try and add
+                  // but still try and do any removals since we don't know which of the imports
+                  // has it
+                  newImports: seen.has(impPath) ? undefined : list,
+                  removeImports,
+                  // don't use normalized path here, we wanna use the path that's in code...
+                  transformPath: impInfo.importPath,
+                },
+              );
+              if (transformed) {
+                newContents += transformed;
+                seen.set(impPath, true);
+                continue;
+              }
+            }
+          }
+        } else {
+          if (
+            !ts.isExportDeclaration(node.node) &&
+            !isRequireStatement(node.node, sourceFile)
+          ) {
+            processAfterImport();
+          }
+        }
+        newContents += node.node.getFullText(sourceFile);
+      } else if (node.rawString) {
+        processAfterImport();
+        newContents += node.rawString;
+      } else {
+        throw new Error(`malformed node with no node or rawString`);
+      }
+    }
+
+    let writeFile = file;
+    if (transform.fileToWrite) {
+      writeFile = transform.fileToWrite(file);
+    }
+    fs.writeFileSync(writeFile, newContents);
+
+    if (transform.postProcess) {
+      transform.postProcess(file);
+    }
+  });
+
+  if (transform.prettierGlob) {
+    execSync(`prettier ${transform.prettierGlob} --write`);
+  }
+}
+
+function isRequireStatement(node: ts.Node, sourceFile: ts.SourceFile) {
+  if (node.kind !== ts.SyntaxKind.VariableStatement) {
+    return false;
+  }
+  const v = node as ts.VariableStatement;
+  const text = v.declarationList.declarations[0].getFullText(sourceFile);
+  return text.includes("require(");
+}

package/src/tsc/transform_action.ts

@@ -0,0 +1,224 @@
+import ts from "typescript";
+import {
+  ClassInfo,
+  getClassInfo,
+  getImportInfo,
+  getPreText,
+  isRelativeGeneratedImport,
+  isSrcGeneratedImport,
+  transformRelative,
+  customInfo,
+} from "../tsc/ast";
+import { Action } from "../action";
+import { LoggedOutViewer } from "../core/viewer";
+import * as path from "path";
+import { Data } from "../core/base";
+import { TransformFile } from "./transform";
+import { snakeCase } from "snake-case";
+
+interface baseFileInfo {
+  input: string;
+  importPath: string;
+}
+
+// returns input and importPath
+function getBaseFileInfo(
+  file: string,
+  classInfo: ClassInfo,
+  sourceFile: ts.SourceFile,
+): baseFileInfo | null {
+  // @ts-ignore
+  const importStatements: ts.ImportDeclaration[] = sourceFile.statements.filter(
+    (stmt) => ts.isImportDeclaration(stmt),
+  );
+
+  for (const imp of importStatements) {
+    const text = imp.moduleSpecifier.getText(sourceFile).slice(1, -1);
+
+    if (
+      isSrcGeneratedImport(imp, sourceFile) ||
+      isRelativeGeneratedImport(imp, sourceFile)
+    ) {
+      // base file and we're importing from it
+      // e.g. in create_user_action, we're importing from create_user_action_base
+      if (path.basename(file).slice(0, -3) + "_base" !== path.basename(text)) {
+        continue;
+      }
+
+      const impInfo = getImportInfo(imp, sourceFile);
+      if (!impInfo) {
+        continue;
+      }
+
+      let inputs = impInfo.imports
+        .filter((imp) => imp.trim() && imp.endsWith("Input"))
+        .map((v) => v.trim());
+      if (inputs.length === 1) {
+        return {
+          input: inputs[0],
+          importPath: impInfo.importPath,
+        };
+      }
+      if (inputs.length && classInfo.name.endsWith("Action")) {
+        const prefix = classInfo.name.slice(0, classInfo.name.length - 6);
+        inputs = inputs.filter(
+          (imp) => imp.slice(0, imp.length - 5) === prefix,
+        );
+        if (inputs.length === 1) {
+          return {
+            input: inputs[0],
+            importPath: impInfo.importPath,
+          };
+        }
+      }
+    }
+  }
+  return null;
+}
+
+interface convertReturnInfo {
+  text: string;
+  method: string;
+  interface: string;
+  methodType: string;
+}
+
+let m: Data = {
+  triggers: {
+    m: "getTriggers",
+    i: "Trigger",
+    suffix: "Triggers",
+  },
+  observers: {
+    m: "getObservers",
+    i: "Observer",
+    suffix: "Observers",
+  },
+  validators: {
+    m: "getValidators",
+    i: "Validator",
+    suffix: "Validators",
+  },
+};
+
+function getConversionInfo(
+  mm: ts.ClassElement,
+  actionName: string,
+): convertReturnInfo | null {
+  if (mm.kind !== ts.SyntaxKind.PropertyDeclaration) {
+    return null;
+  }
+  const text = (mm.name as ts.Identifier).escapedText as string;
+  const v = m[text];
+  if (v === undefined) {
+    return null;
+  }
+  return {
+    text,
+    method: v.m,
+    interface: v.i,
+    // CreateFooActionTriggers etc
+    methodType: actionName + v.suffix,
+  };
+}
+
+export class TransformAction implements TransformFile {
+  glob = "src/ent/**/actions/**/*_action.ts";
+
+  prettierGlob = "src/ent/**/actions/**.ts";
+
+  constructor(private customInfo: customInfo) {}
+
+  traverseChild(
+    sourceFile: ts.SourceFile,
+    contents: string,
+    file: string,
+    node: ts.Node,
+  ) {
+    if (!ts.isClassDeclaration(node) || !node.heritageClauses) {
+      return { node };
+    }
+
+    let classInfo = getClassInfo(contents, sourceFile, node);
+    // only do classes
+    if (!classInfo || !classInfo.default) {
+      return;
+    }
+
+    // require action
+    const p = require(path.join(process.cwd(), "./" + file.slice(0, -3)));
+    const action: Action<any, any> = new p.default(new LoggedOutViewer(), {});
+    const actionName = action.constructor.name;
+
+    const builder = action.builder.constructor.name;
+    const nodeName = action.builder.ent.name;
+    const viewer = this.customInfo.viewerInfo.name;
+
+    const baseInfo = getBaseFileInfo(file, classInfo, sourceFile);
+    if (!baseInfo) {
+      return;
+    }
+
+    let klassContents = "";
+
+    let traversed = false;
+    let newImports: string[] = [];
+    for (const mm of node.members) {
+      const conv = getConversionInfo(mm, actionName);
+      if (conv !== null) {
+        const property = mm as ts.PropertyDeclaration;
+        // if invalid, bounce
+        if (!property.initializer) {
+          return;
+        }
+
+        traversed = true;
+
+        const pp = property.initializer.getFullText(sourceFile).trim();
+        const code = `${conv.method}(): ${conv.methodType} {
+            return ${pp}
+          }`;
+        newImports.push(conv.methodType);
+        klassContents += getPreText(contents, mm, sourceFile) + code;
+      } else {
+        klassContents += mm.getFullText(sourceFile);
+      }
+    }
+
+    const builderPath = `src/ent/generated/${snakeCase(
+      nodeName,
+    )}/actions/${snakeCase(builder)}`;
+
+    let imports: Map<string, string[]> = new Map([
+      [
+        transformRelative(
+          file,
+          this.customInfo.viewerInfo.path,
+          this.customInfo.relativeImports,
+        ),
+        [viewer],
+      ],
+      [
+        transformRelative(
+          file,
+          baseInfo.importPath,
+          this.customInfo.relativeImports,
+        ),
+        newImports,
+      ],
+      [
+        transformRelative(file, builderPath, this.customInfo.relativeImports),
+        [builder],
+      ],
+    ]);
+
+    // wrap comments and transform to export class Foo extends Bar { ${inner} }
+    return {
+      rawString: classInfo.wrapClassContents(klassContents),
+      traversed,
+      imports,
+      removeImports: ["Trigger", "Observer", "Validator"],
+      // not removing FooBuilder incase it's still somehow used in type of inline builders
+    };
+  }
+}

package/src/tsc/transform_ent.ts

@@ -0,0 +1,66 @@
+import { PACKAGE } from "../core/const";
+import ts from "typescript";
+import { getClassInfo, getPreText } from "./ast";
+import { TransformFile } from "./transform";
+
+function isPrivacyPolicy(mm: ts.ClassElement) {
+  return (
+    mm.kind === ts.SyntaxKind.PropertyDeclaration &&
+    (mm.name as ts.Identifier).escapedText === "privacyPolicy"
+  );
+}
+
+export class TransformEnt implements TransformFile {
+  glob = "src/ent/*.ts";
+
+  traverseChild(
+    sourceFile: ts.SourceFile,
+    contents: string,
+    file: string,
+    node: ts.Node,
+  ) {
+    if (!ts.isClassDeclaration(node) || !node.heritageClauses) {
+      return { node };
+    }
+
+    let classInfo = getClassInfo(contents, sourceFile, node);
+    if (!classInfo) {
+      return;
+    }
+    // different class. ignore
+    // only do classes which extend a base class e.g. User extends UserBase
+    // if different class (e.g. privacy rule), just return it
+    if (classInfo.extends !== classInfo.name + "Base") {
+      return { node };
+    }
+
+    let klassContents = "";
+    let traversed = false;
+
+    for (const mm of node.members) {
+      if (isPrivacyPolicy(mm)) {
+        const property = mm as ts.PropertyDeclaration;
+        // if invalid privacy policy, bounce
+        if (!property.initializer) {
+          return;
+        }
+        const pp = property.initializer.getFullText(sourceFile);
+        const code = `getPrivacyPolicy(): PrivacyPolicy<this> {
+            return ${pp}
+          }`;
+        klassContents += getPreText(contents, mm, sourceFile) + code;
+        traversed = true;
+      } else {
+        klassContents += mm.getFullText(sourceFile);
+      }
+    }
+
+    return {
+      rawString: classInfo.wrapClassContents(klassContents),
+      traversed,
+      imports: new Map<string, string[]>([[PACKAGE, ["PrivacyPolicy"]]]),
+    };
+  }
+
+  prettierGlob = "src/ent/*.ts";
+}