@snowtop/ent 0.1.0-alpha124 → 0.1.0-alpha126

package/imports/dataz/example1/_viewer.js

@@ -1,46 +1,94 @@
 "use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
 };
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.push(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.push(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
 };
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const graphql_1 = require("../../../graphql/graphql");
 const graphql_2 = require("graphql");
-let ViewerType = class ViewerType {
-    constructor(viewer) {
-        this.viewer = viewer;
-    }
-    get viewerID() {
-        return this.viewer.viewerID;
-    }
-};
-__decorate([
-    (0, graphql_1.gqlField)({ type: graphql_2.GraphQLID, nullable: true }),
-    __metadata("design:type", Object),
-    __metadata("design:paramtypes", [])
-], ViewerType.prototype, "viewerID", null);
-ViewerType = __decorate([
-    (0, graphql_1.gqlObjectType)({ name: "Viewer" }),
-    __metadata("design:paramtypes", [Object])
-], ViewerType);
-class ViewerResolver {
-    viewer(context) {
-        return new ViewerType(context.getViewer());
-    }
-}
-__decorate([
-    (0, graphql_1.gqlQuery)({ name: "viewer", type: ViewerType }),
-    __param(0, (0, graphql_1.gqlContextType)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", ViewerType)
-], ViewerResolver.prototype, "viewer", null);
-exports.default = ViewerResolver;
+let ViewerType = (() => {
+    let _classDecorators = [(0, graphql_1.gqlObjectType)({ name: "Viewer" })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _instanceExtraInitializers = [];
+    let _get_viewerID_decorators;
+    var ViewerType = _classThis = class {
+        constructor(viewer) {
+            this.viewer = (__runInitializers(this, _instanceExtraInitializers), viewer);
+        }
+        get viewerID() {
+            return this.viewer.viewerID;
+        }
+    };
+    __setFunctionName(_classThis, "ViewerType");
+    (() => {
+        _get_viewerID_decorators = [(0, graphql_1.gqlField)({
+                nodeName: "ViewerType",
+                type: graphql_2.GraphQLID,
+                nullable: true,
+            })];
+        __esDecorate(_classThis, null, _get_viewerID_decorators, { kind: "getter", name: "viewerID", static: false, private: false, access: { has: obj => "viewerID" in obj, get: obj => obj.viewerID } }, null, _instanceExtraInitializers);
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name }, null, _classExtraInitializers);
+        ViewerType = _classThis = _classDescriptor.value;
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return ViewerType = _classThis;
+})();
+exports.default = (() => {
+    var _a;
+    let _instanceExtraInitializers_1 = [];
+    let _viewer_decorators;
+    return _a = class ViewerResolver {
+            viewer(context) {
+                return new ViewerType(context.getViewer());
+            }
+            constructor() {
+                __runInitializers(this, _instanceExtraInitializers_1);
+            }
+        },
+        (() => {
+            _viewer_decorators = [(0, graphql_1.gqlQuery)({
+                    nodeName: "ViewerResolver",
+                    name: "viewer",
+                    type: ViewerType,
+                    args: [(0, graphql_1.gqlContextType)()],
+                })];
+            __esDecorate(_a, null, _viewer_decorators, { kind: "method", name: "viewer", static: false, private: false, access: { has: obj => "viewer" in obj, get: obj => obj.viewer } }, null, _instanceExtraInitializers_1);
+        })(),
+        _a;
+})();

package/index.d.ts

@@ -1,6 +1,5 @@
 export * from "./core/base";
-export { loadEnt, loadCustomData, loadCustomEnts, loadCustomCount, loadEntX, loadEnts, CustomQuery, loadDerivedEnt, loadDerivedEntX, loadEntViaKey, loadEntXViaKey, performRawQuery, loadRowX, loadRow, loadRows, DataOperation, EditNodeOptions, EditNodeOperation, RawQueryOperation, EdgeOperation, DeleteNodeOperation, AssocEdge, AssocEdgeInputOptions, AssocEdgeInput, AssocEdgeData, loadEdgeData, loadEdgeDatas, loadEdges, loadUniqueEdge, loadUniqueNode, loadRawEdgeCountX, loadEdgeForID2, loadNodesByEdge, getEdgeTypeInGroup, } from "./core/ent";
-export { setGlobalSchema } from "./core/global_schema";
+export { loadEnt, loadCustomData, loadCustomEnts, loadCustomCount, loadEntX, loadEnts, CustomQuery, loadDerivedEnt, loadDerivedEntX, loadEntViaKey, loadEntXViaKey, performRawQuery, loadRowX, loadRow, loadRows, DataOperation, EditNodeOptions, EditNodeOperation, RawQueryOperation, EdgeOperation, DeleteNodeOperation, AssocEdge, AssocEdgeInputOptions, AssocEdgeInput, AssocEdgeData, loadEdgeData, loadEdgeDatas, loadEdges, loadUniqueEdge, loadUniqueNode, loadRawEdgeCountX, loadEdgeForID2, loadNodesByEdge, getEdgeTypeInGroup, setGlobalSchema, } from "./core/ent";
 import DB from "./core/db";
 export * from "./core/loaders";
 export { DB };

package/index.js

@@ -63,8 +63,7 @@ Object.defineProperty(exports, "loadRawEdgeCountX", { enumerable: true, get: fun
 Object.defineProperty(exports, "loadEdgeForID2", { enumerable: true, get: function () { return ent_1.loadEdgeForID2; } });
 Object.defineProperty(exports, "loadNodesByEdge", { enumerable: true, get: function () { return ent_1.loadNodesByEdge; } });
 Object.defineProperty(exports, "getEdgeTypeInGroup", { enumerable: true, get: function () { return ent_1.getEdgeTypeInGroup; } });
-var global_schema_1 = require("./core/global_schema");
-Object.defineProperty(exports, "setGlobalSchema", { enumerable: true, get: function () { return global_schema_1.setGlobalSchema; } });
+Object.defineProperty(exports, "setGlobalSchema", { enumerable: true, get: function () { return ent_1.setGlobalSchema; } });
 const db_1 = __importDefault(require("./core/db"));
 exports.DB = db_1.default;
 __exportStar(require("./core/loaders"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowtop/ent",
-  "version": "0.1.0-alpha124",
+  "version": "0.1.0-alpha126",
   "description": "snowtop ent framework",
   "main": "index.js",
   "types": "index.d.ts",
@@ -22,12 +22,11 @@
     "pascal-case": "^3.1.2",
     "pg": "^8.8.0",
     "prettier": "^2.8.1",
-    "reflect-metadata": "^0.1.13",
     "snake-case": "^3.0.4",
     "ts-node": "^10.9.1",
-    "tsconfig-paths": "^4.1.1",
-    "tslib": "^2.4.1",
-    "typescript": "^4.9.4",
+    "tsconfig-paths": "^4.2.0",
+    "tslib": "^2.5.0",
+    "typescript": "^5.0.4",
     "uuid": "^9.0.0"
   },
   "peerDependencies": {

package/parse_schema/parse.d.ts

@@ -83,7 +83,6 @@ interface RomeConfig {
 interface ProcessedGlobalSchema {
     globalEdges: ProcessedAssocEdge[];
     extraEdgeFields: ProcessedField[];
-    init?: boolean;
-    globalFields?: ProcessedField[];
+    initForEdges?: boolean;
 }
 export {};

package/parse_schema/parse.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseSchema = void 0;
 const cosmiconfig_1 = require("cosmiconfig");
 const const_1 = require("../core/const");
-const global_schema_1 = require("../core/global_schema");
 async function processFields(src, patternName) {
     const ret = [];
     let m = {};
@@ -237,9 +236,6 @@ async function parseSchema(potentialSchemas, globalSchema) {
     let parsedGlobalSchema;
     if (globalSchema) {
         parsedGlobalSchema = await parseGlobalSchema(globalSchema);
-        // set this so that we can use it, if we're trying to process server default or anything
-        // that ends up parsing,validating and formatting fields
-        (0, global_schema_1.setGlobalSchema)(globalSchema);
     }
     for (const key in potentialSchemas) {
         const value = potentialSchemas[key];
@@ -358,10 +354,9 @@ async function parseGlobalSchema(s) {
     const ret = {
         globalEdges: [],
         extraEdgeFields: [],
-        init: !!s.extraEdgeFields ||
+        initForEdges: !!s.extraEdgeFields ||
             s.transformEdgeRead !== undefined ||
-            s.transformEdgeWrite !== undefined ||
-            s.fields !== undefined,
+            s.transformEdgeWrite !== undefined,
     };
     if (s.extraEdgeFields) {
         ret.extraEdgeFields = await processFields(s.extraEdgeFields);
@@ -369,8 +364,5 @@ async function parseGlobalSchema(s) {
     if (s.edges) {
         ret.globalEdges = processEdges(s.edges);
     }
-    if (s.fields) {
-        ret.globalFields = await processFields(s.fields);
-    }
     return ret;
 }

package/schema/field.d.ts

@@ -149,7 +149,6 @@ export interface EnumOptions extends FieldOptions {
     graphQLType?: string;
     createEnumType?: boolean;
     disableUnknownType?: boolean;
-    globalType?: string;
 }
 /**
  * @deprecated Use StringEnumField
@@ -159,7 +158,7 @@ export declare class EnumField extends BaseField implements Field {
     private values?;
     private map?;
     constructor(options: StringEnumOptions);
-    valid(val: any): Promise<boolean>;
+    valid(val: any): boolean;
     format(val: any): any;
 }
 export declare class StringEnumField extends EnumField {
@@ -174,18 +173,17 @@ declare type IntEnumMap = {
     [key: string]: number;
 };
 export interface IntegerEnumOptions extends FieldOptions {
-    map?: IntEnumMap;
+    map: IntEnumMap;
     deprecated?: IntEnumMap;
     tsType?: string;
     graphQLType?: string;
     disableUnknownType?: boolean;
-    globalType?: string;
 }
 export declare class IntegerEnumField extends BaseField implements Field {
     type: Type;
     private map;
     constructor(options: IntegerEnumOptions);
-    valid(val: any): Promise<boolean>;
+    valid(val: any): boolean;
     format(val: any): any;
 }
 export declare function IntegerEnumType(options: IntegerEnumOptions): IntegerEnumField;

package/schema/field.js

@@ -31,8 +31,6 @@ const uuid_1 = require("uuid");
 const base_1 = require("../core/base");
 const db_1 = __importStar(require("../core/db"));
 const schema_1 = require("./schema");
-const global_schema_1 = require("../core/global_schema");
-const logger_1 = require("../core/logger");
 class BaseField {
     logValue(val) {
         if (this.sensitive) {
@@ -527,11 +525,10 @@ class EnumField extends BaseField {
             type: options.tsType,
             graphQLType: options.graphQLType,
             disableUnknownType: options.disableUnknownType,
-            globalType: options.globalType,
         };
         if (!options.foreignKey) {
-            if (!options.values && !options.map && !options.globalType) {
-                throw new Error("values, map or globalType required if not look up table enum. Look-up table enum indicated by foreignKey field");
+            if (!options.values && !options.map) {
+                throw new Error("values or map required if not look up table enum. Look-up table enum indicated by foreignKey field");
             }
             if (options.values) {
                 if (!options.values.length) {
@@ -550,8 +547,8 @@ class EnumField extends BaseField {
             }
         }
         else {
-            if (options.values || options.map || options.globalType) {
-                throw new Error("cannot specify values, map or globalType and foreign key for lookup table enum type");
+            if (options.values || options.map) {
+                throw new Error("cannot specify values or map and foreign key for lookup table enum type");
             }
             if (options.createEnumType) {
                 throw new Error("cannot specify createEnumType without specifying values");
@@ -566,20 +563,7 @@ class EnumField extends BaseField {
         this.values = options.values;
         this.map = options.map;
     }
-    async valid(val) {
-        if (this.type.globalType) {
-            const f = (0, global_schema_1.__getGlobalSchemaField)(this.type.globalType);
-            if (f) {
-                if (f.valid) {
-                    return f.valid(val);
-                }
-                return true;
-            }
-            else {
-                (0, logger_1.log)("error", `globalType ${this.type.globalType} not found in global schema`);
-                return false;
-            }
-        }
+    valid(val) {
         // lookup table enum and indicated via presence of foreignKey
         if (!this.values && !this.map) {
             return true;
@@ -597,13 +581,6 @@ class EnumField extends BaseField {
         return false;
     }
     format(val) {
-        if (this.type.globalType) {
-            const f = (0, global_schema_1.__getGlobalSchemaField)(this.type.globalType);
-            if (f && f.format) {
-                return f.format(val);
-            }
-            return val;
-        }
         return val;
     }
 }
@@ -626,46 +603,21 @@ class IntegerEnumField extends BaseField {
             graphQLType: options.graphQLType,
             deprecatedIntEnumMap: options.deprecated,
             disableUnknownType: options.disableUnknownType,
-            globalType: options.globalType,
         };
-        if (options.foreignKey) {
-            throw new Error(`foreignKey on intEnum not supported`);
+        let count = 0;
+        for (const _ in options.map) {
+            count++;
+            break;
         }
-        if (options.globalType) {
-            if (options.map) {
-                throw new Error(`cannot specify map and globalType`);
-            }
-            this.map = {};
+        if (!count) {
+            throw new Error("need at least one entry in enum map");
         }
-        else {
-            let count = 0;
-            for (const _ in options.map) {
-                count++;
-                break;
-            }
-            if (!count) {
-                throw new Error("need at least one entry in enum map");
-            }
-            if (!options.map) {
-                throw new Error("map required if not globalType");
-            }
-            this.map = options.map;
+        if (options.foreignKey) {
+            throw new Error(`foreignKey on intEnum not supported`);
         }
+        this.map = options.map;
     }
-    async valid(val) {
-        if (this.type?.globalType) {
-            const f = (0, global_schema_1.__getGlobalSchemaField)(this.type.globalType);
-            if (f) {
-                if (f.valid) {
-                    return f.valid(val);
-                }
-                return true;
-            }
-            else {
-                (0, logger_1.log)("error", `globalType ${this.type.globalType} not found in global schema`);
-                return false;
-            }
-        }
+    valid(val) {
         // lookup table enum and indicated via presence of foreignKey
         for (const k in this.map) {
             const v = this.map[k];
@@ -676,12 +628,6 @@ class IntegerEnumField extends BaseField {
         return false;
     }
     format(val) {
-        if (this.type.globalType) {
-            const f = (0, global_schema_1.__getGlobalSchemaField)(this.type.globalType);
-            if (f && f.format) {
-                return f.format(val);
-            }
-        }
         return parseInt(val);
     }
 }

package/schema/schema.d.ts

@@ -17,7 +17,6 @@ export interface GlobalSchema {
     extraEdgeFields?: FieldMap;
     transformEdgeRead?: () => Clause;
     transformEdgeWrite?: (stmt: EdgeUpdateOperation) => TransformedEdgeUpdateOperation | null;
-    fields?: FieldMap;
 }
 type FieldOverride = Pick<FieldOptions, "nullable" | "storageKey" | "serverDefault" | "unique" | "hideFromGraphQL" | "graphqlName" | "index">;
 export type FieldOverrideMap = {
@@ -172,7 +171,6 @@ export interface Type {
     intEnumMap?: IntEnumMap;
     deprecatedIntEnumMap?: IntEnumMap;
     disableUnknownType?: boolean;
-    globalType?: string;
     importType?: DeprecatedImportType;
     subFields?: FieldMap;
     unionFields?: FieldMap;

package/schema/struct_field.d.ts

@@ -1,22 +1,20 @@
 import { BaseField, ListField } from "./field";
 import { FieldOptions, Field, Type, FieldMap } from "./schema";
-interface structFieldOptions extends FieldOptions {
+export interface StructOptions extends FieldOptions {
     tsType: string;
     fields: FieldMap;
     graphQLType?: string;
     jsonNotJSONB?: boolean;
 }
-interface GlobalStructOptions extends FieldOptions {
-    globalType: string;
+interface allStructOptions extends StructOptions {
+    jsonAsList?: boolean;
 }
-export type StructOptions = structFieldOptions | GlobalStructOptions;
 export declare class StructField extends BaseField implements Field {
     private options;
-    private jsonAsList?;
     type: Type;
-    constructor(options: StructOptions, jsonAsList?: boolean | undefined);
+    constructor(options: allStructOptions);
     formatImpl(obj: any, nested?: boolean): string | Object;
-    format(obj: any, nested?: boolean): any;
+    format(obj: any, nested?: boolean): string | Object;
     private validImpl;
     valid(obj: any): Promise<boolean>;
 }
@@ -25,5 +23,5 @@ export declare function StructType(options: StructOptions): StructField & Struct
  * @deprecated use StructTypeAsList
  */
 export declare function StructListType(options: StructOptions): ListField;
-export declare function StructTypeAsList(options: StructOptions): StructField & StructOptions;
+export declare function StructTypeAsList(options: allStructOptions): StructField & allStructOptions;
 export {};

package/schema/struct_field.js

@@ -4,24 +4,20 @@ exports.StructTypeAsList = exports.StructListType = exports.StructType = exports
 const camel_case_1 = require("camel-case");
 const field_1 = require("./field");
 const schema_1 = require("./schema");
-const global_schema_1 = require("../core/global_schema");
-const logger_1 = require("../core/logger");
 class StructField extends field_1.BaseField {
-    constructor(options, jsonAsList) {
+    constructor(options) {
         super();
         this.options = options;
-        this.jsonAsList = jsonAsList;
         this.type = {
             dbType: schema_1.DBType.JSONB,
         };
         this.type.subFields = options.fields;
         this.type.type = options.tsType;
         this.type.graphQLType = options.graphQLType || options.tsType;
-        this.type.globalType = this.options.globalType;
         if (options.jsonNotJSONB) {
             this.type.dbType = schema_1.DBType.JSON;
         }
-        if (jsonAsList) {
+        if (options?.jsonAsList) {
             this.type.listElemType = {
                 dbType: schema_1.DBType.JSONB,
             };
@@ -61,37 +57,7 @@ class StructField extends field_1.BaseField {
         return JSON.stringify(ret);
     }
     format(obj, nested) {
-        if (this.type.globalType) {
-            const f = (0, global_schema_1.__getGlobalSchemaField)(this.type.globalType);
-            if (f && f.format) {
-                if (JSON.stringify(this.type.listElemType) !==
-                    JSON.stringify(f?.type.listElemType)) {
-                    if (this.jsonAsList) {
-                        // handle as nested
-                        // @ts-ignore
-                        const formatted = obj.map((v) => f.format(v, true));
-                        if (nested) {
-                            return formatted;
-                        }
-                        else {
-                            return JSON.stringify(formatted);
-                        }
-                    }
-                    else {
-                        const formatted = f.format([obj], true);
-                        if (nested) {
-                            return formatted[0];
-                        }
-                        else {
-                            return JSON.stringify(formatted[0]);
-                        }
-                    }
-                }
-                // TODO handle format code
-                return f.format(obj);
-            }
-        }
-        if (Array.isArray(obj) && this.jsonAsList) {
+        if (Array.isArray(obj) && this.options.jsonAsList) {
             const ret = obj.map((v) => this.formatImpl(v, true));
             if (nested) {
                 return ret;
@@ -136,35 +102,7 @@ class StructField extends field_1.BaseField {
         return ret.every((v) => v);
     }
     async valid(obj) {
-        if (this.type.globalType) {
-            const f = (0, global_schema_1.__getGlobalSchemaField)(this.type.globalType);
-            // list and global type is not valid.
-            if (f) {
-                if (f.valid) {
-                    if (JSON.stringify(this.type.listElemType) !==
-                        JSON.stringify(f?.type.listElemType)) {
-                        if (this.jsonAsList) {
-                            if (!Array.isArray(obj)) {
-                                return false;
-                            }
-                            // @ts-ignore
-                            const valid = await Promise.all(obj.map((v) => f.valid(v)));
-                            return valid.every((b) => b);
-                        }
-                        else {
-                            return f.valid([obj]);
-                        }
-                    }
-                    return f.valid(obj);
-                }
-                return true;
-            }
-            else {
-                (0, logger_1.log)("error", `globalType ${this.type.globalType} not found in global schema`);
-                return false;
-            }
-        }
-        if (this.jsonAsList) {
+        if (this.options.jsonAsList) {
             if (!Array.isArray(obj)) {
                 return false;
             }
@@ -191,7 +129,10 @@ function StructListType(options) {
 }
 exports.StructListType = StructListType;
 function StructTypeAsList(options) {
-    let result = new StructField(options, true);
+    let result = new StructField({
+        ...options,
+        jsonAsList: true,
+    });
     return Object.assign(result, options);
 }
 exports.StructTypeAsList = StructTypeAsList;

package/schema/union_field.d.ts

@@ -15,7 +15,7 @@ export declare class UnionField extends BaseField implements FieldOptions {
     type: Type;
     m: Map<Object, string>;
     constructor(options: UnionOptions);
-    format(obj: any): any;
+    format(obj: any): string | Object;
     private validField;
     valid(obj: any): Promise<boolean>;
 }

package/scripts/custom_compiler.js

@@ -229,7 +229,7 @@ class Compiler {
                     let relPath = checkPath(paths, text);
                     if (relPath) {
                         // update the node...
-                        return typescript_1.default.factory.updateImportDeclaration(importNode, importNode.decorators, importNode.modifiers, importNode.importClause, typescript_1.default.factory.createStringLiteral(relPath), importNode.assertClause);
+                        return typescript_1.default.factory.updateImportDeclaration(importNode, importNode.modifiers, importNode.importClause, typescript_1.default.factory.createStringLiteral(relPath), importNode.assertClause);
                     }
                 }
                 if (node.kind === typescript_1.default.SyntaxKind.ExportDeclaration) {
@@ -239,7 +239,7 @@ class Compiler {
                         let relPath = checkPath(paths, text);
                         if (relPath) {
                             // update the node...
-                            return typescript_1.default.updateExportDeclaration(exportNode, exportNode.decorators, exportNode.modifiers, exportNode.exportClause, typescript_1.default.factory.createStringLiteral(relPath), exportNode.isTypeOnly);
+                            return typescript_1.default.factory.updateExportDeclaration(exportNode, exportNode.modifiers, exportNode.isTypeOnly, exportNode.exportClause, typescript_1.default.factory.createStringLiteral(relPath), exportNode.assertClause);
                         }
                     }
                 }

package/scripts/move_types.js

@@ -36,7 +36,10 @@ class GatherExportsInGeneratedTypes {
         this.names = [];
     }
     traverseChild(sourceFile, contents, file, node) {
-        const exported = node.modifiers?.filter((mod) => mod.getText(sourceFile) === "export");
+        const modifiers = typescript_1.default.canHaveModifiers(node)
+            ? typescript_1.default.getModifiers(node)
+            : undefined;
+        const exported = modifiers?.filter((mod) => mod.getText(sourceFile) === "export");
         if (exported?.length) {
             if (typescript_1.default.isEnumDeclaration(node) ||
                 typescript_1.default.isInterfaceDeclaration(node) ||

package/testutils/db_mock.js

@@ -263,10 +263,10 @@ class QueryRecorder {
         });
     }
 }
-exports.QueryRecorder = QueryRecorder;
 QueryRecorder.queries = [];
 QueryRecorder.ids = [];
 // we need pkeys when storing...
 QueryRecorder.data = new Map();
+exports.QueryRecorder = QueryRecorder;
 // TODO
 process.env.DB_CONNECTION_STRING = "INVALID DATABASE";

package/testutils/fake_comms.js

@@ -32,5 +32,5 @@ class FakeComms {
         this.sent = [];
     }
 }
-exports.FakeComms = FakeComms;
 FakeComms.sent = [];
+exports.FakeComms = FakeComms;

package/testutils/fake_log.js

@@ -21,12 +21,12 @@ class FakeLogger {
         this.logs = [];
     }
 }
-exports.FakeLogger = FakeLogger;
 // todo this is quick and ideal.
 // more ideal is capturing all console.logs
 // we do it in golang for example
 // and will need this for production launch anyways
 FakeLogger.logs = [];
+exports.FakeLogger = FakeLogger;
 // TODO instead of needing to add this manually
 // we need to build a way to add global observers (and maybe triggers)
 // to be run on every action/mutation