@aeriajs/compiler 0.0.4 → 0.0.7

package/dist/semantic.d.ts

@@ -0,0 +1,5 @@
+import { Diagnostic } from './diagnostic.js';
+import * as AST from './ast.js';
+export declare const analyze: (ast: AST.ProgramNode, errors?: Diagnostic[]) => Promise<{
+    errors: Diagnostic[];
+}>;

package/dist/semantic.js

@@ -0,0 +1,149 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyze = void 0;
+const common_1 = require("@aeriajs/common");
+const parser_js_1 = require("./parser.js");
+const diagnostic_js_1 = require("./diagnostic.js");
+const AST = __importStar(require("./ast.js"));
+const collectionHasProperty = async (collection, propName) => {
+    let hasProperty = propName in collection.properties;
+    if (!hasProperty) {
+        if (collection.extends) {
+            const { packageName, symbolName } = collection.extends;
+            const { [symbolName]: importedCollection } = await Promise.resolve(`${packageName}`).then(s => __importStar(require(s)));
+            if (!(0, common_1.isValidCollection)(importedCollection)) {
+                throw new Error;
+            }
+            hasProperty = propName in importedCollection.description.properties;
+        }
+    }
+    return hasProperty;
+};
+const analyze = async (ast, errors = []) => {
+    const checkCollectionForeignProperties = async (foreignCollection, property, attributeName) => {
+        if (!property[attributeName]) {
+            return;
+        }
+        for (const foreignPropName of property[attributeName]) {
+            if (!await collectionHasProperty(foreignCollection, foreignPropName)) {
+                let location;
+                if (property[AST.LOCATION_SYMBOL]) {
+                    location = parser_js_1.locationMap.get(property[AST.LOCATION_SYMBOL].attributes[attributeName]);
+                }
+                errors.push(new diagnostic_js_1.Diagnostic(`collection "${foreignCollection.name}" hasn't such property "${foreignPropName}"`, location));
+            }
+        }
+    };
+    const checkCollectionLocalProperties = async (node, attributeName) => {
+        if (!node[attributeName]) {
+            return;
+        }
+        for (const index in node[attributeName]) {
+            const propName = node[attributeName][index];
+            const symbol = node[AST.LOCATION_SYMBOL].arrays[attributeName][index];
+            if (!await collectionHasProperty(node, propName)) {
+                const location = parser_js_1.locationMap.get(symbol);
+                errors.push(new diagnostic_js_1.Diagnostic(`collection "${node.name}" hasn't such property "${propName}"`, location));
+            }
+        }
+    };
+    const checkObjectLocalProperties = async (node, attributeName) => {
+        if (!('properties' in node.property) || !node.property[attributeName]) {
+            return;
+        }
+        for (const index in node.property[attributeName]) {
+            const propName = node.property[attributeName][index];
+            const symbol = node.property[AST.LOCATION_SYMBOL].arrays[attributeName][index];
+            if (!(propName in node.property.properties)) {
+                const location = parser_js_1.locationMap.get(symbol);
+                errors.push(new diagnostic_js_1.Diagnostic(`object "xxx" hasn't such property "${propName}"`, location));
+            }
+        }
+    };
+    const recurseProperty = async (node) => {
+        if (node.nestedProperties && 'nestedProperties' in node) {
+            await checkObjectLocalProperties(node, 'required');
+            await checkObjectLocalProperties(node, 'writable');
+            await checkObjectLocalProperties(node, 'form');
+            for (const propName in node.nestedProperties) {
+                const subProperty = node.nestedProperties[propName];
+                await recurseProperty(subProperty);
+            }
+        }
+        else if ('$ref' in node.property) {
+            const refName = node.property.$ref;
+            const foreignCollection = ast.collections.find(({ name }) => name === refName);
+            if (!foreignCollection) {
+                throw new Error;
+            }
+            await checkCollectionForeignProperties(foreignCollection, node.property, 'indexes');
+            await checkCollectionForeignProperties(foreignCollection, node.property, 'populate');
+            await checkCollectionForeignProperties(foreignCollection, node.property, 'form');
+        }
+    };
+    for (const node of ast.collections) {
+        await checkCollectionLocalProperties(node, 'indexes');
+        await checkCollectionLocalProperties(node, 'filters');
+        await checkCollectionLocalProperties(node, 'form');
+        await checkCollectionLocalProperties(node, 'table');
+        for (const propName in node.properties) {
+            const subNode = node.properties[propName];
+            await recurseProperty(subNode);
+        }
+    }
+    for (const node of ast.contracts) {
+        if (node.payload) {
+            await recurseProperty(node.payload);
+        }
+        if (node.query) {
+            await recurseProperty(node.query);
+        }
+        if (node.response) {
+            if (Array.isArray(node.response)) {
+                for (const subNode of node.response) {
+                    await recurseProperty(subNode);
+                }
+            }
+            else {
+                await recurseProperty(node.response);
+            }
+        }
+    }
+    return {
+        errors,
+    };
+};
+exports.analyze = analyze;

package/dist/semantic.mjs

@@ -0,0 +1,111 @@
+"use strict";
+import { isValidCollection } from "@aeriajs/common";
+import { locationMap } from "./parser.mjs";
+import { Diagnostic } from "./diagnostic.mjs";
+import * as AST from "./ast.mjs";
+const collectionHasProperty = async (collection, propName) => {
+  let hasProperty = propName in collection.properties;
+  if (!hasProperty) {
+    if (collection.extends) {
+      const { packageName, symbolName } = collection.extends;
+      const { [symbolName]: importedCollection } = await import(packageName);
+      if (!isValidCollection(importedCollection)) {
+        throw new Error();
+      }
+      hasProperty = propName in importedCollection.description.properties;
+    }
+  }
+  return hasProperty;
+};
+export const analyze = async (ast, errors = []) => {
+  const checkCollectionForeignProperties = async (foreignCollection, property, attributeName) => {
+    if (!property[attributeName]) {
+      return;
+    }
+    for (const foreignPropName of property[attributeName]) {
+      if (!await collectionHasProperty(foreignCollection, foreignPropName)) {
+        let location;
+        if (property[AST.LOCATION_SYMBOL]) {
+          location = locationMap.get(property[AST.LOCATION_SYMBOL].attributes[attributeName]);
+        }
+        errors.push(new Diagnostic(`collection "${foreignCollection.name}" hasn't such property "${foreignPropName}"`, location));
+      }
+    }
+  };
+  const checkCollectionLocalProperties = async (node, attributeName) => {
+    if (!node[attributeName]) {
+      return;
+    }
+    for (const index in node[attributeName]) {
+      const propName = node[attributeName][index];
+      const symbol = node[AST.LOCATION_SYMBOL].arrays[attributeName][index];
+      if (!await collectionHasProperty(node, propName)) {
+        const location = locationMap.get(symbol);
+        errors.push(new Diagnostic(`collection "${node.name}" hasn't such property "${propName}"`, location));
+      }
+    }
+  };
+  const checkObjectLocalProperties = async (node, attributeName) => {
+    if (!("properties" in node.property) || !node.property[attributeName]) {
+      return;
+    }
+    for (const index in node.property[attributeName]) {
+      const propName = node.property[attributeName][index];
+      const symbol = node.property[AST.LOCATION_SYMBOL].arrays[attributeName][index];
+      if (!(propName in node.property.properties)) {
+        const location = locationMap.get(symbol);
+        errors.push(new Diagnostic(`object "xxx" hasn't such property "${propName}"`, location));
+      }
+    }
+  };
+  const recurseProperty = async (node) => {
+    if (node.nestedProperties && "nestedProperties" in node) {
+      await checkObjectLocalProperties(node, "required");
+      await checkObjectLocalProperties(node, "writable");
+      await checkObjectLocalProperties(node, "form");
+      for (const propName in node.nestedProperties) {
+        const subProperty = node.nestedProperties[propName];
+        await recurseProperty(subProperty);
+      }
+    } else if ("$ref" in node.property) {
+      const refName = node.property.$ref;
+      const foreignCollection = ast.collections.find(({ name }) => name === refName);
+      if (!foreignCollection) {
+        throw new Error();
+      }
+      await checkCollectionForeignProperties(foreignCollection, node.property, "indexes");
+      await checkCollectionForeignProperties(foreignCollection, node.property, "populate");
+      await checkCollectionForeignProperties(foreignCollection, node.property, "form");
+    }
+  };
+  for (const node of ast.collections) {
+    await checkCollectionLocalProperties(node, "indexes");
+    await checkCollectionLocalProperties(node, "filters");
+    await checkCollectionLocalProperties(node, "form");
+    await checkCollectionLocalProperties(node, "table");
+    for (const propName in node.properties) {
+      const subNode = node.properties[propName];
+      await recurseProperty(subNode);
+    }
+  }
+  for (const node of ast.contracts) {
+    if (node.payload) {
+      await recurseProperty(node.payload);
+    }
+    if (node.query) {
+      await recurseProperty(node.query);
+    }
+    if (node.response) {
+      if (Array.isArray(node.response)) {
+        for (const subNode of node.response) {
+          await recurseProperty(subNode);
+        }
+      } else {
+        await recurseProperty(node.response);
+      }
+    }
+  }
+  return {
+    errors
+  };
+};

package/dist/token.d.ts

@@ -0,0 +1,38 @@
+export declare const TokenType: {
+    readonly LineBreak: "LINE_BREAK";
+    readonly Comment: "COMMENT";
+    readonly LeftBracket: "LEFT_BRACKET";
+    readonly RightBracket: "RIGHT_BRACKET";
+    readonly LeftParens: "LEFT_PARENS";
+    readonly RightParens: "RIGHT_PARENS";
+    readonly LeftSquareBracket: "LEFT_SQUARE_BRACKET";
+    readonly RightSquareBracket: "RIGHT_SQUARE_BRACKET";
+    readonly Pipe: "PIPE";
+    readonly Comma: "COMMA";
+    readonly Dot: "DOT";
+    readonly Number: "NUMBER";
+    readonly Boolean: "BOOLEAN";
+    readonly Keyword: "KEYWORD";
+    readonly Identifier: "IDENTIFIER";
+    readonly QuotedString: "QUOTED_STRING";
+    readonly AttributeName: "ATTRIBUTE_NAME";
+    readonly MacroName: "MACRO_NAME";
+    readonly Range: "RANGE";
+};
+export type TokenType = typeof TokenType[keyof typeof TokenType];
+export type TypeMap = {
+    [TokenType.Number]: number;
+    [TokenType.Boolean]: boolean;
+    [TokenType.Range]: readonly [number, number];
+};
+export type Location = {
+    index: number;
+    line: number;
+    start: number;
+    end: number;
+};
+export type Token<TTokenType extends TokenType = TokenType, TValue = TTokenType extends keyof TypeMap ? TypeMap[TTokenType] : string> = {
+    type: TTokenType;
+    location: Location;
+    value: TValue;
+};

package/dist/token.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenType = void 0;
+exports.TokenType = {
+    LineBreak: 'LINE_BREAK',
+    Comment: 'COMMENT',
+    LeftBracket: 'LEFT_BRACKET',
+    RightBracket: 'RIGHT_BRACKET',
+    LeftParens: 'LEFT_PARENS',
+    RightParens: 'RIGHT_PARENS',
+    LeftSquareBracket: 'LEFT_SQUARE_BRACKET',
+    RightSquareBracket: 'RIGHT_SQUARE_BRACKET',
+    Pipe: 'PIPE',
+    Comma: 'COMMA',
+    Dot: 'DOT',
+    Number: 'NUMBER',
+    Boolean: 'BOOLEAN',
+    Keyword: 'KEYWORD',
+    Identifier: 'IDENTIFIER',
+    QuotedString: 'QUOTED_STRING',
+    AttributeName: 'ATTRIBUTE_NAME',
+    MacroName: 'MACRO_NAME',
+    Range: 'RANGE',
+};

package/dist/token.mjs

@@ -0,0 +1,22 @@
+"use strict";
+export const TokenType = {
+  LineBreak: "LINE_BREAK",
+  Comment: "COMMENT",
+  LeftBracket: "LEFT_BRACKET",
+  RightBracket: "RIGHT_BRACKET",
+  LeftParens: "LEFT_PARENS",
+  RightParens: "RIGHT_PARENS",
+  LeftSquareBracket: "LEFT_SQUARE_BRACKET",
+  RightSquareBracket: "RIGHT_SQUARE_BRACKET",
+  Pipe: "PIPE",
+  Comma: "COMMA",
+  Dot: "DOT",
+  Number: "NUMBER",
+  Boolean: "BOOLEAN",
+  Keyword: "KEYWORD",
+  Identifier: "IDENTIFIER",
+  QuotedString: "QUOTED_STRING",
+  AttributeName: "ATTRIBUTE_NAME",
+  MacroName: "MACRO_NAME",
+  Range: "RANGE"
+};

package/dist/utils.d.ts

@@ -0,0 +1,3 @@
+export type ArrayProperties<T> = keyof {
+    [P in Extract<keyof T, string> as NonNullable<T[P]> extends string[] | readonly string[] ? P : never]: never;
+};

package/dist/utils.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils.mjs

@@ -0,0 +1 @@
+"use strict";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aeriajs/compiler",
-  "version": "0.0.4",
+  "version": "0.0.7",
   "description": "",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -10,8 +10,7 @@
   },
   "exports": {
     ".": {
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.js",
+      "import": "./dist/index.js",
       "types": "./dist/index.d.ts"
     }
   },