@effect-app/eslint-codegen-model 0.7.0

package/src/compiler.ts

@@ -0,0 +1,235 @@
+import ts, { SyntaxKind } from "typescript"
+
+const sortUnion = (a: string, b: string) => {
+  if (a !== "null" && a!== "undefined" && (b === "null" || b === "undefined")) {
+    return -1
+  }
+  if (b !== "null" && b !== "undefined" && (a === "null" || a === "undefined")) {
+    return 1
+  }
+  if(a < b) { return -1; }
+  if(a > b) { return 1; }
+  return 0;
+}
+
+const sortAlpha = (a: string, b: string) => {
+  if(a < b) { return -1; }
+  if(a > b) { return 1; }
+  return 0;
+}
+
+// TODO: we don't support string literals with spaces in them currently.
+const rx = /(([^\s\<\>\,\[\(]+)? \| ([^\s\<\>\,\]\)]+))+/
+
+function sortIt(str: string) {
+  return str.split(" | ").sort(sortUnion).join(" | ")
+}
+
+const debug = false // true
+
+export function processNode(tc: ts.TypeChecker, root: ts.Node) {
+  return (n: ts.Node) => {
+    if (/*ts.isClassDeclaration(n) || ts.isTypeAliasDeclaration(n)*/ true) {
+      const constructorName = (n as any).name?.escapedText
+
+      if (!constructorName?.endsWith("Constructor")) {
+        //console.log("$$$constructorName doesnt end with Constructor", constructorName)
+        return
+      }
+
+      //console.log("$$$ constructorName", constructorName)
+
+      const t = tc.getTypeAtLocation(n)
+
+      const result = { encoded: [] as string[], parsed: [] as string[] }
+      const unions: Record<string, string> = {}
+
+      //console.log("$$$ props", t.getProperties().map(x => x.escapedName))
+      t.getProperties().forEach((c) => {
+        const method = c.name
+        if (method === "encoded" || method === "parsed") {
+          //console.log("$$$ method", method)
+          //console.log(c.members)
+          const tt = tc.getTypeOfSymbolAtLocation(c, n)
+          // const s = tc.getReturnTypeOfSignature(tt.getCallSignatures()[0])
+
+          // const type = tc.getReturnTypeOfSignature(s! as any /* TODO */)
+
+
+          tt.getProperties().forEach(p => {
+            const isLookup = debug && p.escapedName === "carrier"
+
+            //kind = 207, 
+            //arguments[0].escapedText === "HosterRole"
+            //console.log("$$$p", p.escapedName)
+            //if (p.escapedName === "opposite") {
+              //console.log("$$$ a union!", p.declarations?.map(x => x.forEachChild(c => {
+
+              // TODO: have to find nullable, array, set, map, etc.
+              // TODO: "Encoded"
+              // but also should find fully custom sets like PurchaseOrderModulesSet - we should be able to just use those directly, incl PurchaseOrderModulesSet.Encoded
+              // for now just skip them?
+                p.declarations?.map(x => x.forEachChild(c => {
+                  if (isLookup) {
+                    console.log("$$$ lookup", c.kind, c)
+                  }
+                if (c.kind === SyntaxKind.CallExpression) { // 207 -- SyntaxKind.ElementAccessExpression) {
+                  let it = (c as any).arguments[0]
+                  //const isState = p.escapedName === "state"
+                  if (isLookup) {
+                    console.log("$$$ state it", it)
+                  }
+                  const isNullable = it.expression?.escapedText === "nullable"
+                  const isIt = it.arguments && it.arguments[0] //it.expression?.escapedText === "nullable"
+                  if (isIt) {
+                    //console.log("$$ nullable", it.arguments[0])
+                    // TODO: usually the union is on the last input, we need to support all elements individually however
+                    it = it.arguments[it.arguments.length - 1]
+                  }
+                  //console.log("$args", it)
+                  //tc.getTypeAtLocation(it)
+                  const tt = tc.getTypeAtLocation(c) //tc.getTypeOfSymbolAtLocation(it.parent, n)
+                  const typeDecl = tc.typeToString(
+                    tt,
+                    root,
+                    ts.TypeFormatFlags.NoTruncation
+                    //ts.TypeFormatFlags.None
+                    //ts.TypeFormatFlags.AddUndefined |
+                    // | ts.TypeFormatFlags.NoTypeReduction
+                    //    | ts.TypeFormatFlags.MultilineObjectLiterals
+                       //| ts.TypeFormatFlags.InTypeAlias
+                      | ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope // prevents import(*)
+                    //  | ts.TypeFormatFlags.UseStructuralFallback
+                  )
+                  if (isLookup) {
+                    console.log("$$ type", typeDecl)
+                  }
+                  const matches = typeDecl.match(rx)
+                  if (isLookup) {
+                    console.log("$$ matches", matches)
+                }
+                const isOptional = typeDecl.match(/\>, "optional"/)
+                  if (matches) {
+                    let replaced = matches[0]!.replace(rx, (match) => sortIt(match))
+                    replaced = sortIt(isOptional ? isNullable ? replaced.replace(" | null", " | undefined | null") : replaced + " | undefined" : replaced)
+                    //console.log("$$ replaced", replaced, it.escapedText, matches)
+                    // if (it.escapedText === "TaskState") {
+                    //   console.log("Help", it)
+                    // }
+                    if (isLookup) {
+                      console.log("$$$ replaced", it.escapedText, replaced)
+                    }
+                    if (it.escapedText && !it.escapedText.endsWith("Set") /* skip the "Set" problem */ && replaced.replace(" | null", "").includes("|")) {
+                      const replacement = it.escapedText + (isNullable ? " | null" : "") + (isOptional ? " | undefined" : "")
+                      // if (it.escapedText === "TaskState") {
+                      //   console.log("$$$", { replaced, replacement })
+                      //   unions[replaced] = replacement  
+                      // } else {
+                      unions[replaced] = replacement
+                      if (isLookup) {
+                        console.log("$$ repl", { replaced, replacement})
+                      }
+                      //}
+                    } else {
+                    //   if (isIt) {
+                    //     console.log("$$ no name found", it.escapedText)
+                    // }
+                    //   console.log("$$ no name found??", it)
+                    }
+                  }
+                  
+                }
+                //c.kind === 346 ? console.log(c) : null
+                //console.log((c as any).flowNode?.node?.name)
+              }))
+            //}
+          })
+
+          if (debug && Object.keys(unions).length) {
+            console.log("$$$ unions to replace", unions)
+          }
+
+          const typeDecl = tc.typeToString(
+            tt,
+            root,
+            ts.TypeFormatFlags.NoTruncation
+            //ts.TypeFormatFlags.None
+            //ts.TypeFormatFlags.AddUndefined |
+            // | ts.TypeFormatFlags.NoTypeReduction
+            //    | ts.TypeFormatFlags.MultilineObjectLiterals
+               //| ts.TypeFormatFlags.InTypeAlias
+              | ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope // prevents import(*)
+            //  | ts.TypeFormatFlags.UseStructuralFallback
+          )
+          const str = typeDecl === "{}" ? [] :
+          // drop leading { and trailing }
+          typeDecl.substring(2, typeDecl.length - 2)
+            .split(";")
+            .map(l => l.trim())
+            // todo; skip the first split, as its the property
+            .map(l => l.replace(rx, (match) => {
+                const rpl = sortIt(match)
+                //if (debug) { console.log("Searching for", rpl, { unions}) }
+                if (rpl.endsWith(" | undefined")) {
+                  const sub = unions[rpl.replace(" | undefined", "")]
+                  return sub ? sub + " | undefined" : unions[rpl] ?? rpl
+                }
+
+                const sub = unions[rpl]
+                return (sub ? sub : rpl)
+              })
+              .replaceAll(" Array<", " ReadonlyArray<") // .replaceAll(/(Array|Set|Map)\</", "ReadonlyArray<") //
+              .replaceAll(" Set<", " ROSet<")
+              .replaceAll(" Map<", " ROMap<")
+              .replaceAll("(Array<", "(ReadonlyArray<") // .replaceAll(/(Array|Set|Map)\</", "ReadonlyArray<") //
+              .replaceAll("(Set<", "(ROSet<")
+              .replaceAll("(Map<", "(ROMap<")
+                .replaceAll(" Array.Array<", " ReadonlyArray<") // .replaceAll(/(Array|Set|Map)\</", "ReadonlyArray<") //
+                .replaceAll(" Set.Set<", " ROSet<")
+                .replaceAll(" Map.Map<", " ROMap<")
+            )
+          // we sort for now, because otherwise we have sometimes multiple times changing back and forth between editor and console.
+          .sort(sortAlpha)
+          // Taken care of by "ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope"
+          //.replaceAll(/import\("[^"]+"\)\./g, "")
+
+          result[method] = str
+        }
+      })
+
+      if (!("parsed" in result)) {
+        throw new Error("No parsed result")
+      }
+      if (!("encoded" in result)) {
+        throw new Error("No encoded result")
+      }
+
+      const modelName = constructorName.replace("Constructor", "")
+
+      const encoded = result.encoded.filter(x => !!x)
+      const parsed = result.parsed.filter(x => !!x)
+
+      return [
+        `export interface ${modelName} {${parsed.length ? "\n" + parsed.map(l => "  " + l).join("\n") + "\n" : ""}}`,
+        `export namespace ${modelName} {`,
+        `  /**`,
+        `   * @tsplus type ${modelName}.Encoded`,
+        `   */`,
+        `  export interface Encoded {${encoded.length ? "\n" + encoded.map(l => "    " + l).join("\n") + "\n  " : ""}}`,
+        `  export const Encoded: EncodedOps = { $: {} }`,
+        `  /**`,
+        `   * @tsplus type ${modelName}.Encoded/Aspects`,
+        `   */`,
+        `  export interface EncodedAspects {}`,
+        `  /**`,
+        `   * @tsplus type ${modelName}.Encoded/Ops`,
+        `   */`,
+        `  export interface EncodedOps { $: EncodedAspects }`,
+        "  export interface ConstructorInput",
+        `    extends ConstructorInputFromApi<typeof ${modelName}> {}`,
+        `  export interface Props extends GetProvidedProps<typeof ${modelName}> {}`,
+        "}",
+      ]
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+// codegen:start {preset: barrel, include: ./*/, nodir: false }
+export * from './presets';
+// codegen:end

package/src/presets/barrel.ts

@@ -0,0 +1,150 @@
+import generate from '@babel/generator';
+import { parse } from '@babel/parser';
+import type { Preset } from 'eslint-plugin-codegen';
+import * as glob from 'glob';
+import { match } from 'io-ts-extra';
+import * as lodash from 'lodash';
+import * as path from 'path';
+
+/**
+ * Bundle several modules into a single convenient one.
+ *
+ * @example
+ * // codegen:start {preset: barrel, include: some/path/*.ts, exclude: some/path/*util.ts}
+ * export * from './some/path/module-a'
+ * export * from './some/path/module-b'
+ * export * from './some/path/module-c'
+ * // codegen:end
+ *
+ * @param include
+ * [optional] If specified, the barrel will only include file paths that match this glob pattern
+ * @param exclude
+ * [optional] If specified, the barrel will exclude file paths that match these glob patterns
+ * @param import
+ * [optional] If specified, matching files will be imported and re-exported rather than directly exported
+ * with `export * from './xyz'`. Use `import: star` for `import * as xyz from './xyz'` style imports.
+ * Use `import: default` for `import xyz from './xyz'` style imports.
+ * @param export
+ * [optional] Only valid if the import style has been specified (either `import: star` or `import: default`).
+ * If specified, matching modules will be bundled into a const or default export based on this name. If set
+ * to `{name: someName, keys: path}` the relative file paths will be used as keys. Otherwise the file paths
+ * will be camel-cased to make them valid js identifiers.
+ */
+export const barrel: Preset<{
+  include?: string;
+  exclude?: string | string[];
+  import?: 'default' | 'star';
+  export?:
+    | string
+    | { name: string; keys: 'path' | 'camelCase' }
+    | { as: 'PascalCase', postfix?: string };
+  nodir?: boolean;
+}> = ({ meta, options: opts }) => {
+  const cwd = path.dirname(meta.filename);
+  const nodir = opts.nodir ?? true;
+
+  const ext = meta.filename.split('.').slice(-1)[0];
+  const pattern = opts.include || `*.${ext}`;
+
+  const relativeFiles = glob
+    .sync(pattern, { cwd, ignore: opts.exclude, nodir })
+    .filter((f) => path.resolve(cwd, f) !== path.resolve(meta.filename))
+    .map((f) => `./${f}`.replace(/(\.\/)+\./g, '.'))
+    .filter((file) =>
+      nodir
+        ? ['.js', '.mjs', '.ts', '.tsx'].includes(path.extname(file))
+        : true,
+    )
+    .map((f) => f.replace(/\.\w+$/, '').replace(/\/$/, ''));
+  
+  function last<T>(list: readonly T[]) {
+    return list[list.length - 1]
+  }
+
+  const expectedContent = match(opts.import)
+    .case(undefined, () =>
+      match(opts.export)
+        .case({ as: 'PascalCase' as const }, (v) =>
+          lodash
+            .chain(relativeFiles)
+            .map(
+              (f) =>
+                `export * as ${lodash
+                  .startCase(lodash.camelCase(last(f.split("/"))))
+                  .replace(/ /g, "") // why?
+                  .replace(/\//, '')}${"postfix" in v ? v.postfix : ''} from '${f}.js'`,
+            )
+            .value()
+            .join('\n'),
+        )
+        .default(() => {
+          return relativeFiles.map((f) => `export * from '${f}.js'`).join('\n');
+        })
+        .get(),
+    )
+    .case(String, (s) => {
+      const importPrefix = s === 'default' ? '' : '* as ';
+      const withIdentifiers = lodash
+        .chain(relativeFiles)
+        .map((f) => ({
+          file: f,
+          identifier: lodash
+            .camelCase(f)
+            .replace(/^([^a-z])/, '_$1')
+            .replace(/Index$/, ''),
+        }))
+        .groupBy((info) => info.identifier)
+        .values()
+        .flatMap((group) =>
+          group.length === 1
+            ? group
+            : group.map((info, i) => ({
+                ...info,
+                identifier: `${info.identifier}_${i + 1}`,
+              })),
+        )
+        .value();
+
+      const imports = withIdentifiers
+        .map((i) => `import ${importPrefix}${i.identifier} from '${i.file}.js'`)
+        .join('\n');
+      const exportProps = match(opts.export)
+        .case({ name: String, keys: 'path' }, () =>
+          withIdentifiers.map(
+            (i) => `${JSON.stringify(i.file)}: ${i.identifier}`,
+          ),
+        )
+        .default(() => withIdentifiers.map((i) => i.identifier))
+        .get();
+
+      const exportPrefix = match(opts.export)
+        .case(undefined, () => 'export')
+        .case('default', () => 'export default')
+        .case({ name: 'default' }, () => 'export default')
+        .case(String, (name) => `export const ${name} =`)
+        .case({ name: String }, ({ name }) => `export const ${name} =`)
+        .default(() => '')
+        .get();
+
+      const exports = exportProps.join(',\n ');
+
+      return `${imports}\n\n${exportPrefix} {\n ${exports}\n}\n`;
+    })
+    .get();
+
+  // ignore stylistic differences. babel generate deals with most
+  const normalise = (str: string) =>
+    generate(
+      parse(str, { sourceType: 'module', plugins: ['typescript'] }) as any,
+    )
+      .code.replace(/'/g, `"`)
+      .replace(/\/index/g, '');
+
+  try {
+    if (normalise(expectedContent) === normalise(meta.existingContent)) {
+      return meta.existingContent;
+    }
+  } catch {}
+
+  return expectedContent;
+};

package/src/presets/index.ts

@@ -0,0 +1,4 @@
+// codegen:start {preset: barrel, include: ./*.ts}
+export * from './barrel';
+export * from './model';
+// codegen:end

package/src/presets/model.ts

@@ -0,0 +1,114 @@
+import generate from "@babel/generator"
+import { parse } from "@babel/parser"
+import type { Preset } from "eslint-plugin-codegen"
+import * as fs from "fs"
+import { processNode } from "../compiler"
+function normalise(str: string) {
+  try {
+    return generate(
+      parse(str, { sourceType: "module", plugins: ["typescript"] }) as any
+    )
+      .code
+      // .replace(/'/g, `"`)
+      // .replace(/\/index/g, "")
+      //.replace(/([\n\s]+ \|)/g, " |").replaceAll(": |", ":")
+      //.replaceAll(/[\s\n]+\|/g, " |")
+      //.replaceAll("\n", ";")
+      //.replaceAll(" ", "")
+      // TODO: remove all \n and whitespace?
+  } catch (e) {
+    return str
+  }
+}
+// TODO: get shared compiler host...
+import { ESLintUtils } from "@typescript-eslint/utils"
+export const model: Preset<{
+  exclude?: string
+}> = ({ meta }, context: any) => {
+  if (!context.parserOptions.project) {
+    console.warn(`${meta.filename}: Cannot run ESLint Model plugin, because no TS Compiler is enabled`)
+    return meta.existingContent
+  }
+
+  try {
+    // option to exclude some methods
+    //const exclude = (options.exclude || "").split(",")
+
+    // checks and reads the file
+    const sourcePath = meta.filename
+    if (!fs.existsSync(sourcePath) || !fs.statSync(sourcePath).isFile()) {
+      throw Error(`Source path is not a file: ${sourcePath}`)
+    }
+    // const cfgFile = ts.findConfigFile(sourcePath, (fn) => fs.existsSync(fn))
+    // if (!cfgFile) {
+    //   throw new Error("No TS config file found")
+    // }
+
+    // const cfg = ts.readConfigFile(cfgFile, (fn) => fs.readFileSync(fn, "utf-8"))
+    // const basePath = path.dirname(cfgFile); // equal to "getDirectoryPath" from ts, at least in our case.
+    // const parsedConfig = ts.parseJsonConfigFileContent(cfg.config, ts.sys, basePath);
+
+    // const program = ts.createProgram([sourcePath], parsedConfig.options)
+
+
+    const { program } = ESLintUtils.getParserServices(context);
+
+    //console.log("$$ processing", sourcePath)
+
+    // create and parse the AST
+    const sourceFile = program.getSourceFile(
+      sourcePath,
+    )!
+
+    // collect data-first declarations
+    // const dataFirstDeclarations = sourceFile.statements
+    //   .filter(ts.isFunctionDeclaration)
+    //   // .filter(
+    //   //   (node) =>
+    //   //     node.modifiers &&
+    //   //     node.modifiers.filter(
+    //   //       (modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword
+    //   //     ).length > 0
+    //   // )
+    //   // .filter((node) => !!node.name)
+    //   // .filter((node) => node.parameters.length >= 2)
+    //   // .filter((node) => node.name!.getText(sourceFile).endsWith("_"))
+    //   // .map((node) => ({
+    //   //   functionName: node.name!.getText(sourceFile),
+    //   //   typeParameters: node.typeParameters || ts.factory.createNodeArray(),
+    //   //   parameters: node.parameters || ts.factory.createNodeArray(),
+    //   //   type: node.type!,
+    //   //   implemented: !!node.body,
+    //   //   jsDoc: getJSDoc(node)
+    //   // }))
+    //   // .filter((decl) => exclude.indexOf(decl.functionName) === -1)
+
+    // // create the actual AST nodes
+    // const nodes = dataFirstDeclarations.map(createPipeableFunctionDeclaration)
+    // const expectedContent = nodes.map((node) => printNode(node, sourceFile)).join("\n")
+
+    const pn = processNode(program.getTypeChecker(), sourceFile)
+    let abc: (string[] | undefined)[] = []
+    // TODO: must return void, cannot use getChildren() etc, or it wont work, no idea why!  
+    sourceFile.forEachChild(c => {abc = abc.concat(pn(c))})
+    const expectedContent = [
+      "//",
+      `/* eslint-disable */`,      
+      ...abc.filter((x): x is string[] => !!x),
+      `/* eslint-enable */`,
+      "//"
+    ].join("\n")
+
+    // do not re-emit in a different style, or a loop will occur
+    if (normalise(meta.existingContent) === normalise(expectedContent))
+      return meta.existingContent
+    return expectedContent
+  } catch (e) {
+    return (
+      "/** Got exception: " +
+      ("stack" in (e as any) ? (e as any).stack : "") +
+      JSON.stringify(e) +
+      "*/"
+    )
+  }
+}

package/tsconfig.json

@@ -0,0 +1,94 @@
+{
+  "compilerOptions": {
+    "strict": true,
+    "allowUnusedLabels": false,
+    "allowUnreachableCode": false,
+    "exactOptionalPropertyTypes": false,
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitOverride": true,
+    "noImplicitReturns": false,
+    "noPropertyAccessFromIndexSignature": true,
+    "noUncheckedIndexedAccess": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "importsNotUsedAsValues": "error",
+    "checkJs": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "module": "CommonJS",
+    "lib": [
+      "esnext"
+    ],
+    "target": "ES2018",
+    "inlineSourceMap": true,
+    "incremental": true,
+    "composite": true,
+    "declarationMap": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "noImplicitAny": true,
+    "useUnknownInCatchVariables": true,
+    "noImplicitThis": true,
+    "outDir": "./dist",
+    "resolveJsonModule": true,
+    "moduleResolution": "Node16",
+    "downlevelIteration": true,
+    "noErrorTruncation": true,
+    "tsPlusTypes": [
+      "./node_modules/@effect-app/core/vendor/effect-ts-tsplus.json",
+      "./node_modules/@effect-app/core/vendor/effect-io-tsplus.json",
+      "./node_modules/@effect-app/core/vendor/effect-stm-tsplus.json",
+      "./node_modules/@effect-app/core/vendor/effect-stream-tsplus.json",
+      "./node_modules/@effect-app/core/vendor/fp-ts-data-tsplus.json"
+    ],
+    "plugins": [
+      {
+        "name": "@effect/language-service",
+        "diagnostics": {
+          "1002": "none"
+        }
+      }
+    ],
+    "transformers": [
+      {
+        "name": "@effect/language-service/transformer",
+        "trace": {}
+      }
+    ],
+    "baseUrl": ".",
+    "tsBuildInfoFile": "./dist/.tsbuildinfo",
+    "rootDir": "./src"
+  },
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "display": "Strictest",
+  "watchOptions": {
+    "watchFile": "useFsEvents",
+    "watchDirectory": "useFsEvents",
+    "fallbackPolling": "dynamicPriority",
+    "excludeDirectories": [
+      "**/node_modules",
+      "**/dist",
+      "**/.build",
+      "**/.git",
+      "**/.data",
+      "**/.logs",
+      "**/.*"
+    ],
+    "excludeFiles": [
+      "**/*.tmp",
+      "openapi.json",
+      "*.json"
+    ]
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "**/node_modules",
+    "**/build",
+    "**/dist",
+    "**/.*"
+  ],
+  "references": []
+}

package/tsconfig.json.bak

@@ -0,0 +1,16 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "baseUrl": ".",
+    "outDir": "./dist",
+    "tsBuildInfoFile": "./dist/.tsbuildinfo",
+    "rootDir": "./src",
+    "target": "ES2018",
+    "module": "CommonJS",
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true
+  },
+  "include": [
+    "src/**/*"
+  ]
+}