WRAP ABI 0.2 Refactor

packages/schema/compose/package.json → packages/schema/abi-types/package.json

@@ -1,6 +1,6 @@
 {
-  "name": "@polywrap/schema-compose",
-  "description": "Polywrap Schema Composition",
+  "name": "@polywrap/abi-types",
+  "description": "Polywrap ABI Core Types",
   "version": "0.10.0-pre.5",
   "license": "MIT",
   "repository": {
@@ -13,24 +13,17 @@
   ],
   "scripts": {
     "build": "rimraf ./build && tsc --project tsconfig.build.json",
-    "lint": "eslint --color -c ../../../.eslintrc.js src/",
+    "lint": "eslint --color src/",
     "test": "jest --passWithNoTests --runInBand --verbose",
     "test:ci": "jest --passWithNoTests --runInBand --verbose",
     "test:watch": "jest --watch --passWithNoTests --verbose"
   },
-  "dependencies": {
-    "@polywrap/schema-parse": "0.10.0-pre.5",
-    "@polywrap/wrap-manifest-types-js": "0.10.0-pre.5",
-    "graphql": "15.5.0",
-    "mustache": "4.0.1"
-  },
   "devDependencies": {
     "@polywrap/test-cases": "0.10.0-pre.5",
+    "@types/deep-equal": "1.0.1",
     "@types/jest": "26.0.8",
-    "@types/mustache": "4.0.1",
     "@types/prettier": "2.6.0",
     "jest": "26.6.3",
-    "jest-diff": "28.1.3",
     "rimraf": "3.0.2",
     "ts-jest": "26.5.4",
     "ts-node": "8.10.2",

packages/schema/abi-types/src/definitions.ts

@@ -0,0 +1,182 @@
+/// ABIs
+
+export interface AbiDefs {
+  functions?: FunctionDef[];
+  objects?: ObjectDef[];
+  enums?: EnumDef[];
+}
+
+export interface Abi extends AbiDefs {
+  version: "0.2";
+  imports?: ImportedAbi[];
+}
+
+export type ImportAbiType =
+  | "wasm"
+  | "interface";
+
+export interface ImportedAbi extends AbiDefs {
+  id: string;
+  uri: string;
+  type: ImportAbiType;
+  namespace: string;
+  imports?: ImportedAbi[];
+}
+
+/// Definitions (user-defined)
+
+export type AnyDef = FunctionDef | ObjectDef | EnumDef | PropertyDef | ArgumentDef | ResultDef;
+
+export type UniqueDefKind =
+  | "Function"
+  | "Object"
+  | "Enum"
+
+export type DefKind =
+  | UniqueDefKind
+  | "Argument"
+  | "Result"
+  | "Property";
+
+export interface Def {
+  kind: DefKind;
+}
+
+export interface NamedDef extends Def {
+  name: string;
+}
+
+export interface InlinedTypeDef extends Def, OptionalType { }
+
+export interface NamedTypeDef extends NamedDef, InlinedTypeDef { }
+
+export interface FunctionDef extends NamedDef {
+  kind: "Function";
+  args: ArgumentDef[];
+  result: ResultDef;
+}
+
+export interface ArgumentDef extends NamedTypeDef {
+  kind: "Argument";
+}
+
+export interface ResultDef extends InlinedTypeDef {
+  kind: "Result";
+}
+
+export interface ObjectDef extends NamedDef {
+  kind: "Object";
+  props: PropertyDef[];
+}
+
+export interface PropertyDef extends NamedTypeDef {
+  kind: "Property";
+}
+
+export interface EnumDef extends NamedDef {
+  kind: "Enum";
+  constants: string[];
+}
+
+/// Types (built-ins)
+
+export type AnyType =
+  | ScalarType
+  | ArrayType
+  | MapType
+  | RefType
+  | ImportRefType
+  | UnlinkedImportRefType;
+
+export type TypeKind =
+  | "Scalar"
+  | "Array"
+  | "Map"
+  | "Ref"
+  | "ImportRef"
+  | "UnlinkedImportRef"
+
+export interface Type {
+  kind: TypeKind;
+}
+
+export interface ScalarType<
+  TScalarTypeName extends ScalarTypeName = ScalarTypeName
+> extends Type {
+  kind: "Scalar";
+  scalar: TScalarTypeName;
+}
+
+export interface ArrayType extends Type {
+  kind: "Array";
+  item: OptionalType;
+}
+
+export interface MapType extends Type {
+  kind: "Map";
+  key: ScalarType<MapKeyTypeName>;
+  value: OptionalType;
+}
+
+export interface RefType extends Type {
+  kind: "Ref";
+  ref_kind: UniqueDefKind;
+  ref_name: string;
+}
+
+export interface ImportRefType extends Type {
+  kind: "ImportRef";
+  import_id: string;
+  ref_kind: UniqueDefKind;
+  ref_name: string;
+}
+
+export interface UnlinkedImportRefType extends Type {
+  kind: "UnlinkedImportRef";
+  namespaced_ref_name: string;
+}
+
+export interface OptionalType {
+  required: boolean;
+  type: AnyType;
+}
+
+/// Constants
+
+export const scalarTypeSet = {
+  UInt: "UInt",
+  UInt8: "UInt8",
+  UInt16: "UInt16",
+  UInt32: "UInt32",
+  Int: "Int",
+  Int8: "Int8",
+  Int16: "Int16",
+  Int32: "Int32",
+  String: "String",
+  Boolean: "Boolean",
+  Bytes: "Bytes",
+  // TODO: remove complex types
+  BigInt: "BigInt",
+  BigNumber: "BigNumber",
+  JSON: "JSON",
+};
+export type ScalarTypeSet = typeof scalarTypeSet;
+
+export type ScalarTypeName = keyof ScalarTypeSet;
+
+export const mapKeyTypeSet = {
+  UInt: "UInt",
+  UInt8: "UInt8",
+  UInt16: "UInt16",
+  UInt32: "UInt32",
+  Int: "Int",
+  Int8: "Int8",
+  Int16: "Int16",
+  Int32: "Int32",
+  String: "String",
+};
+export type MapKeyTypeSet = typeof mapKeyTypeSet;
+
+export type MapKeyTypeName = keyof MapKeyTypeSet;
+
+export type AnyTypeOrDef = AnyType | AnyDef;

packages/schema/abi-types/src/index.ts

@@ -0,0 +1,46 @@
+import { Abi } from "./definitions";
+
+export * from "./definitions";
+
+export interface ImportStatement {
+  kind: "local" | "external";
+  importedTypes: string[];
+  uriOrPath: string;
+}
+
+export interface ExternalImportStatement extends ImportStatement {
+  kind: "external";
+  namespace: string;
+}
+
+export interface LocalImportStatement extends ImportStatement {
+  kind: "local";
+}
+
+export interface SchemaParser {
+  parseExternalImportStatements: (schema: string) => Promise<ExternalImportStatement[]>
+  parseLocalImportStatements: (schema: string) => Promise<LocalImportStatement[]>
+  parse: (schema: string) => Promise<Abi>
+}
+
+export interface SchemaRenderer {
+  render: (abi: Abi) => Promise<string>
+}
+
+export interface ParserOptions {
+  noValidate?: boolean;
+}
+
+export interface ExternalSchemaFetcher {
+  fetch: (uri: string) => Promise<Abi>;
+}
+
+export interface LocalSchemaFetcher {
+  fetch: (path: string) => Promise<string>;
+}
+
+export function createAbi(): Abi {
+  return {
+    version: "0.2"
+  };
+}

packages/schema/abi/.eslintrc.js

@@ -0,0 +1,95 @@
+
+module.exports = {
+  extends: "../../../.eslintrc.js",
+  overrides: [
+    {
+      files: ["*.ts"],
+      parser: "@typescript-eslint/parser",
+      parserOptions: {
+        project: ["tsconfig.json"],
+      },
+      plugins: [
+        "eslint-plugin-import",
+        "@typescript-eslint",
+        "prettier"
+      ],
+      extends: [
+        "eslint:recommended",
+        "plugin:@typescript-eslint/eslint-recommended",
+        "plugin:@typescript-eslint/recommended",
+        "prettier",
+      ],
+      rules: {
+        "prettier/prettier": ["error"],
+        "@typescript-eslint/naming-convention": [
+          "error",
+          {selector: "default", format: ["camelCase"]},
+          {
+            selector: [
+              "classProperty", "parameterProperty",
+              "classMethod", "parameter"
+            ],
+            format: ["camelCase"],
+            leadingUnderscore: "allow"
+          },
+          //wrapper host methods doesn"t satisfy neither camel or snake
+          {selector: ["objectLiteralMethod", "typeMethod"], filter: {regex: "^_wrap_.*", match: true}, format: null},
+          //variable must be in camel or upper case
+          {selector: "variable", format: ["camelCase", "PascalCase", "UPPER_CASE"], leadingUnderscore: "allow"},
+          //classes and types must be in PascalCase
+          {selector: ["typeLike", "enum"], format: ["PascalCase"]},
+          {selector: "enumMember", format: null},
+          //ignore rule for quoted stuff
+          {
+            selector: [
+              "classProperty",
+              "objectLiteralProperty",
+              "typeProperty",
+              "classMethod",
+              "objectLiteralMethod",
+              "typeMethod",
+              "accessor",
+              "enumMember"
+            ],
+            format: null,
+            modifiers: ["requiresQuotes"]
+          },
+          //ignore rules on destructured params
+          {
+            selector: "variable",
+            modifiers: ["destructured"],
+            format: null
+          },
+          {
+            selector: [
+              "objectLiteralProperty",
+              "objectLiteralMethod",
+            ],
+            format: ["PascalCase", "camelCase"]
+          },
+        ],
+        "@typescript-eslint/explicit-module-boundary-types": "error",
+        "@typescript-eslint/member-ordering": "error",
+        "@typescript-eslint/no-explicit-any": "error",
+        "@typescript-eslint/no-require-imports": "error",
+        "@typescript-eslint/no-unused-vars": ["error", {
+          "varsIgnorePattern": "^_",
+          "argsIgnorePattern": "^_",
+        }],
+        "@typescript-eslint/no-floating-promises": "error",
+        "import/no-extraneous-dependencies": ["error", {
+          "devDependencies": false,
+          "optionalDependencies": true,
+          "peerDependencies": false
+        }],
+        "import/order": [
+          "error",
+          {
+            "groups": [["index", "sibling", "parent", "internal"], ["external", "builtin"], "object"],
+            "newlines-between": "always"
+          }
+        ],
+      },
+    },
+  ],
+};