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

package/src/tsc/move_generated.ts

@@ -1,191 +0,0 @@
-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

@@ -1,226 +0,0 @@
-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

@@ -1,224 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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";
-}