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

package/src/testutils/test_edge_global_schema.ts

@@ -0,0 +1,49 @@
+import {
+  SQLStatementOperation,
+  TimestampType,
+  EdgeUpdateOperation,
+  TransformedEdgeUpdateOperation,
+} from "../schema";
+import * as clause from "../core/clause";
+import { AssocEdge } from "../core/ent";
+import { Data } from "../core/base";
+
+export class EdgeWithDeletedAt extends AssocEdge {
+  deletedAt: Date | null;
+
+  constructor(data: Data) {
+    super(data);
+    this.deletedAt = data.deleted_at;
+  }
+}
+
+export const testEdgeGlobalSchema = {
+  extraEdgeFields: {
+    // need this to be lowerCamelCase because we do this based on field name
+    // #510
+    deletedAt: TimestampType({
+      nullable: true,
+      index: true,
+      defaultValueOnCreate: () => null,
+    }),
+  },
+
+  transformEdgeRead(): clause.Clause {
+    return clause.Eq("deleted_at", null);
+  },
+
+  transformEdgeWrite(
+    stmt: EdgeUpdateOperation,
+  ): TransformedEdgeUpdateOperation | null {
+    switch (stmt.op) {
+      case SQLStatementOperation.Delete:
+        return {
+          op: SQLStatementOperation.Update,
+          data: {
+            deleted_at: new Date(),
+          },
+        };
+    }
+    return null;
+  },
+};

package/src/testutils/write.ts

@@ -0,0 +1,70 @@
+import {
+  EditRowOptions,
+  Data,
+  DataOptions,
+  CreateRowOptions,
+} from "../core/base";
+import {
+  createRow,
+  editRow,
+  deleteRows,
+  createRowSync,
+  editRowSync,
+  deleteRowsSync,
+} from "../core/ent";
+import * as clause from "../core/clause";
+import DB, { Client, Dialect, SyncClient } from "../core/db";
+
+function isSyncClient(client: Client): client is SyncClient {
+  return (client as SyncClient).execSync !== undefined;
+}
+
+export async function createRowForTest(
+  options: CreateRowOptions,
+  suffix?: string,
+): Promise<Data | null> {
+  let client: Client;
+  if (Dialect.SQLite === DB.getDialect()) {
+    client = DB.getInstance().getSQLiteClient();
+  } else {
+    client = await DB.getInstance().getNewClient();
+  }
+
+  try {
+    if (isSyncClient(client)) {
+      return createRowSync(client, options, suffix || "");
+    }
+    return await createRow(client, options, suffix || "");
+  } finally {
+    client.release();
+  }
+}
+
+export async function editRowForTest(options: EditRowOptions, suffix?: string) {
+  const client = await DB.getInstance().getNewClient();
+
+  try {
+    if (isSyncClient(client)) {
+      return editRowSync(client, options, suffix || "");
+    }
+    return await editRow(client, options, suffix);
+  } finally {
+    client.release();
+  }
+}
+
+export async function deleteRowsForTest(
+  options: DataOptions,
+  cls: clause.Clause,
+) {
+  const client = await DB.getInstance().getNewClient();
+
+  try {
+    if (isSyncClient(client)) {
+      return deleteRowsSync(client, options, cls);
+    }
+    return await deleteRows(client, options, cls);
+  } finally {
+    client.release();
+  }
+}

package/src/tsc/ast.ts

@@ -0,0 +1,351 @@
+import { Data } from "../core/base";
+import ts from "typescript";
+import * as path from "path";
+import { load } from "js-yaml";
+import { ConfigWithCodegen } from "../core/config";
+import * as fs from "fs";
+import { PACKAGE } from "../core/const";
+
+export function getPreText(
+  fileContents: string,
+  node: ts.Node,
+  sourceFile: ts.SourceFile,
+): string {
+  return fileContents.substring(node.getFullStart(), node.getStart(sourceFile));
+}
+
+export interface ClassInfo {
+  extends?: string;
+  comment: string;
+  name: string;
+  export?: boolean;
+  default?: boolean;
+  //  implementsSchema?: boolean;
+  implements?: string[];
+  wrapClassContents(inner: string): string;
+}
+
+export function getClassInfo(
+  fileContents: string,
+  sourceFile: ts.SourceFile,
+  node: ts.ClassDeclaration,
+): ClassInfo | undefined {
+  let className = node.name?.text;
+
+  let classExtends: string | undefined;
+  let impl: string[] = [];
+  if (node.heritageClauses) {
+    for (const hc of node.heritageClauses) {
+      switch (hc.token) {
+        case ts.SyntaxKind.ImplementsKeyword:
+          for (const type of hc.types) {
+            impl.push(type.expression.getText(sourceFile));
+          }
+          break;
+
+        case ts.SyntaxKind.ExtendsKeyword:
+          // can only extend one class
+          for (const type of hc.types) {
+            const text = type.expression.getText(sourceFile);
+            classExtends = text;
+          }
+          break;
+      }
+    }
+  }
+
+  if (!className) {
+    return undefined;
+  }
+
+  let hasExport = false;
+  let hasDefault = false;
+  let comment = getPreText(fileContents, node, sourceFile);
+
+  const wrapClassContents = (inner: string) => {
+    let ret = `${comment}`;
+    if (hasExport) {
+      ret += "export ";
+    }
+    if (hasDefault) {
+      ret += "default ";
+    }
+    ret += `class ${className} `;
+    if (classExtends) {
+      ret += `extends ${classExtends} `;
+    }
+    if (impl.length) {
+      ret += `implements ${impl.join(", ")}`;
+    }
+
+    return `${ret}{
+      ${inner}
+    }`;
+  };
+
+  if (node.modifiers) {
+    for (const mod of node.modifiers) {
+      const text = mod.getText(sourceFile);
+      if (text === "export") {
+        hasExport = true;
+      } else if (text === "default") {
+        hasDefault = true;
+      }
+    }
+  }
+
+  return {
+    name: className,
+    extends: classExtends,
+    comment,
+    implements: impl,
+    wrapClassContents,
+    export: hasExport,
+    default: hasDefault,
+  };
+}
+
+type transformImportFn = (imp: string) => string;
+
+interface transformOpts {
+  removeImports?: string[];
+  newImports?: string[];
+  transform?: transformImportFn;
+  transformPath: string;
+}
+
+export function transformImport(
+  fileContents: string,
+  importNode: ts.ImportDeclaration,
+  sourceFile: ts.SourceFile,
+  opts: transformOpts,
+): string | undefined {
+  // remove quotes too
+  const text = importNode.moduleSpecifier.getText(sourceFile).slice(1, -1);
+  if (text != opts.transformPath) {
+    return;
+  }
+
+  const impInfo = getImportInfo(importNode, sourceFile);
+  if (!impInfo) {
+    return;
+  }
+  let { imports, start, end, importText, default: def } = impInfo;
+
+  let removeImportsMap: Data = {};
+  if (opts?.removeImports) {
+    opts.removeImports.forEach((imp) => {
+      removeImportsMap[imp] = true;
+      if (def === imp) {
+        def = "";
+      }
+    });
+  }
+  let finalImports = new Set<string>();
+
+  for (let i = 0; i < imports.length; i++) {
+    let imp = imports[i].trim();
+    if (imp === "") {
+      continue;
+    }
+    if (opts?.transform) {
+      imp = opts.transform(imp);
+    }
+    if (removeImportsMap[imp]) {
+      continue;
+    }
+    finalImports.add(imp);
+  }
+  if (opts?.newImports) {
+    opts.newImports.forEach((imp) => finalImports.add(imp));
+  }
+
+  const comment = getPreText(fileContents, importNode, sourceFile);
+
+  if (!finalImports.size) {
+    return;
+  }
+
+  return (
+    comment +
+    "import " +
+    // add default
+    (def || "") +
+    // should probably always be "{" now that we support default
+    (start >= 0 ? importText.substring(0, start + 1) : "{") +
+    Array.from(finalImports).join(", ") +
+    // should probably always be "}"
+    (end >= 0 ? importText.substring(end) : "}") +
+    ' from "' +
+    text +
+    '";'
+  );
+}
+
+export function updateImportPath(
+  fileContents: string,
+  importNode: ts.ImportDeclaration,
+  sourceFile: ts.SourceFile,
+  newPath: string,
+) {
+  const comment = getPreText(fileContents, importNode, sourceFile);
+
+  // all this copied from above...
+  const importText = importNode.importClause?.getText(sourceFile) || "";
+  const start = importText.indexOf("{");
+  const end = importText.lastIndexOf("}");
+  if (start === -1 || end === -1) {
+    return;
+  }
+  const imports = importText
+    .substring(start + 1, end)
+    //    .trim()
+    .split(",");
+
+  return (
+    comment +
+    "import " +
+    importText.substring(0, start + 1) +
+    Array.from(imports).join(", ") +
+    importText.substring(end) +
+    ' from "' +
+    newPath +
+    '";'
+  );
+}
+
+export function isRelativeImport(
+  node: ts.ImportDeclaration,
+  sourceFile: ts.SourceFile,
+) {
+  const text = node.moduleSpecifier.getText(sourceFile).slice(1, -1);
+  return text.startsWith("..") || text.startsWith("./");
+}
+
+export function isRelativeGeneratedImport(
+  node: ts.ImportDeclaration,
+  sourceFile: ts.SourceFile,
+) {
+  const text = node.moduleSpecifier.getText(sourceFile).slice(1, -1);
+  return (
+    (text.startsWith("..") || text.startsWith("./")) &&
+    text.indexOf("/generated") !== -1
+  );
+}
+
+export function isSrcGeneratedImport(
+  node: ts.ImportDeclaration,
+  sourceFile: ts.SourceFile,
+) {
+  const text = node.moduleSpecifier.getText(sourceFile).slice(1, -1);
+  return text.startsWith("src") && text.includes("/generated");
+}
+
+interface importInfo {
+  imports: string[];
+  start: number;
+  end: number;
+  importText: string;
+  importPath: string;
+  default?: string;
+}
+
+// TODO doesn't support default + {} yet
+export function getImportInfo(
+  imp: ts.ImportDeclaration,
+  sourceFile: ts.SourceFile,
+): importInfo | undefined {
+  const importText = imp.importClause?.getText(sourceFile) || "";
+  const start = importText.indexOf("{");
+  const end = importText.lastIndexOf("}");
+  const text = imp.moduleSpecifier.getText(sourceFile).slice(1, -1);
+
+  if ((start === -1 || end === -1) && !importText.length) {
+    return;
+  }
+  let imports: string[] = [];
+  let def: string | undefined;
+  if (start !== -1 && end !== -1) {
+    imports = importText
+      .substring(start + 1, end)
+      //.trim()
+      .split(",");
+  } else {
+    def = importText;
+  }
+
+  return {
+    importPath: text,
+    importText,
+    start,
+    end,
+    imports,
+    default: def,
+  };
+}
+
+export function transformRelative(
+  file: string,
+  importPath: string,
+  relative?: boolean,
+): string {
+  if (!relative || !importPath.startsWith("src")) {
+    return importPath;
+  }
+
+  const fileFullPath = path.join(process.cwd(), file);
+  const impFullPath = path.join(process.cwd(), importPath);
+  // relative path is from directory
+  return normalizePath(path.relative(path.dirname(fileFullPath), impFullPath));
+}
+
+function normalizePath(p: string) {
+  if (p.endsWith("..")) {
+    return p + "/";
+  }
+  if (!p.startsWith("..")) {
+    return "./" + p;
+  }
+  return p;
+}
+
+export interface customInfo {
+  viewerInfo: {
+    path: string;
+    name: string;
+  };
+  relativeImports?: boolean;
+  globalSchemaPath?: string;
+}
+
+// also used in parse schema logic
+export function getCustomInfo(): customInfo {
+  let yaml: ConfigWithCodegen | undefined = {};
+
+  let relativeImports = false;
+  try {
+    yaml = load(
+      fs.readFileSync(path.join(process.cwd(), "ent.yml"), {
+        encoding: "utf8",
+      }),
+    ) as ConfigWithCodegen;
+
+    relativeImports = yaml?.codegen?.relativeImports || false;
+
+    if (yaml?.codegen?.templatizedViewer) {
+      return {
+        viewerInfo: yaml.codegen.templatizedViewer,
+        relativeImports,
+        globalSchemaPath: yaml.globalSchemaPath,
+      };
+    }
+  } catch (e) {}
+  return {
+    viewerInfo: {
+      path: PACKAGE,
+      name: "Viewer",
+    },
+    relativeImports,
+    globalSchemaPath: yaml.globalSchemaPath,
+  };
+}

package/src/tsc/compilerOptions.ts

@@ -0,0 +1,85 @@
+import * as fs from "fs";
+import JSON5 from "json5";
+import ts from "typescript";
+import * as path from "path";
+
+function findTSConfigFile(filePath: string): string | null {
+  while (filePath != "/") {
+    let configPath = `${filePath}/tsconfig.json`;
+    if (fs.existsSync(configPath)) {
+      return configPath;
+    }
+    filePath = path.join(filePath, "..");
+  }
+  return null;
+}
+
+export function readCompilerOptions(filePath: string) {
+  let configPath = findTSConfigFile(filePath);
+  if (!configPath) {
+    return {};
+  }
+
+  let json: any = {};
+  try {
+    json = JSON5.parse(
+      fs.readFileSync(configPath, {
+        encoding: "utf8",
+      }),
+    );
+  } catch (e) {
+    console.error("couldn't read tsconfig.json file");
+  }
+  let options: ts.CompilerOptions = json["compilerOptions"] || {};
+  // @ts-ignore
+  if (options.moduleResolution === "node") {
+    options.moduleResolution = ts.ModuleResolutionKind.NodeJs;
+  }
+  return options;
+}
+
+export function getTarget(target?: string): ts.ScriptTarget {
+  switch (target?.toLowerCase()) {
+    case "es2015":
+      return ts.ScriptTarget.ES2015;
+    case "es2016":
+      return ts.ScriptTarget.ES2016;
+    case "es2017":
+      return ts.ScriptTarget.ES2017;
+    case "es2018":
+      return ts.ScriptTarget.ES2018;
+    case "es2019":
+      return ts.ScriptTarget.ES2019;
+    case "es2020":
+      return ts.ScriptTarget.ES2020;
+    case "es2021":
+      return ts.ScriptTarget.ES2021;
+    case "es3":
+      return ts.ScriptTarget.ES3;
+    case "es5":
+      return ts.ScriptTarget.ES5;
+    case "esnext":
+      return ts.ScriptTarget.ESNext;
+    default:
+      return ts.ScriptTarget.ESNext;
+  }
+}
+
+export function getTargetFromCurrentDir(): ts.ScriptTarget {
+  const options = readCompilerOptions(".");
+  return getTarget(options.target?.toString());
+}
+
+export function createSourceFile(target: ts.ScriptTarget, file: string) {
+  let contents = fs.readFileSync(file).toString();
+
+  // go through the file and print everything back if not starting immediately after other position
+  const sourceFile = ts.createSourceFile(
+    file,
+    contents,
+    target,
+    false,
+    ts.ScriptKind.TS,
+  );
+  return { contents, sourceFile };
+}