@snowtop/ent 0.1.0-alpha13 → 0.1.0-alpha16

package/core/privacy.d.ts

@@ -6,22 +6,22 @@ export declare class EntPrivacyError extends Error implements PrivacyError {
     constructor(privacyPolicy: PrivacyPolicy, rule: PrivacyPolicyRule, ent?: Ent);
 }
 export declare const AlwaysAllowRule: {
-    apply(_v: Viewer, _ent?: Ent | undefined): Promise<PrivacyResult>;
+    apply(_v: Viewer, _ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
 };
 export declare const AlwaysDenyRule: {
-    apply(_v: Viewer, _ent?: Ent | undefined): Promise<PrivacyResult>;
+    apply(_v: Viewer, _ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
 };
 export declare const DenyIfLoggedOutRule: {
-    apply(v: Viewer, _ent?: Ent | undefined): Promise<PrivacyResult>;
+    apply(v: Viewer, _ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
 };
 export declare const DenyIfLoggedInRule: {
-    apply(v: Viewer, _ent?: Ent | undefined): Promise<PrivacyResult>;
+    apply(v: Viewer, _ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
 };
 export declare const AllowIfHasIdentity: {
-    apply(v: Viewer, _ent?: Ent | undefined): Promise<PrivacyResult>;
+    apply(v: Viewer, _ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
 };
 export declare const AllowIfViewerRule: {
-    apply(v: Viewer, ent?: Ent | undefined): Promise<PrivacyResult>;
+    apply(v: Viewer, ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
 };
 export declare class AllowIfViewerEqualsRule {
     private id;
@@ -71,45 +71,45 @@ export declare class DenyIfEntPropertyIsRule<T extends Ent> implements PrivacyPo
     constructor(property: keyof T, val: any);
     apply(v: Viewer, ent?: T): Promise<PrivacyResult>;
 }
-export declare class AllowIfEntIsVisibleRule<T extends Ent> implements PrivacyPolicyRule {
+export declare class AllowIfEntIsVisibleRule<TEnt extends Ent<TViewer>, TViewer extends Viewer> implements PrivacyPolicyRule {
     private id;
     private options;
-    constructor(id: ID, options: LoadEntOptions<T>);
-    apply(v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
+    constructor(id: ID, options: LoadEntOptions<TEnt, TViewer>);
+    apply(v: TViewer, _ent?: Ent): Promise<PrivacyResult>;
 }
-export declare class AllowIfEntIsNotVisibleRule<T extends Ent> implements PrivacyPolicyRule {
+export declare class AllowIfEntIsNotVisibleRule<TEnt extends Ent<TViewer>, TViewer extends Viewer> implements PrivacyPolicyRule {
     private id;
     private options;
-    constructor(id: ID, options: LoadEntOptions<T>);
-    apply(v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
+    constructor(id: ID, options: LoadEntOptions<TEnt, TViewer>);
+    apply(v: TViewer, _ent?: Ent): Promise<PrivacyResult>;
 }
-export declare class AllowIfEntIsVisiblePolicy<T extends Ent> implements PrivacyPolicy {
+export declare class AllowIfEntIsVisiblePolicy<TEnt extends Ent<TViewer>, TViewer extends Viewer> implements PrivacyPolicy<TEnt, TViewer> {
     private id;
     private options;
-    constructor(id: ID, options: LoadEntOptions<T>);
+    constructor(id: ID, options: LoadEntOptions<TEnt, TViewer>);
     rules: {
-        apply(_v: Viewer, _ent?: Ent | undefined): Promise<PrivacyResult>;
+        apply(_v: Viewer<Ent<any> | null, ID | null>, _ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
     }[];
 }
-export declare class DenyIfEntIsVisiblePolicy<T extends Ent> implements PrivacyPolicy {
+export declare class DenyIfEntIsVisiblePolicy<TEnt extends Ent<TViewer>, TViewer extends Viewer> implements PrivacyPolicy<TEnt, TViewer> {
     private id;
     private options;
-    constructor(id: ID, options: LoadEntOptions<T>);
+    constructor(id: ID, options: LoadEntOptions<TEnt, TViewer>);
     rules: {
-        apply(_v: Viewer, _ent?: Ent | undefined): Promise<PrivacyResult>;
+        apply(_v: Viewer<Ent<any> | null, ID | null>, _ent?: Ent<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<PrivacyResult>;
     }[];
 }
-export declare class DenyIfEntIsVisibleRule<T extends Ent> implements PrivacyPolicyRule {
+export declare class DenyIfEntIsVisibleRule<TEnt extends Ent<TViewer>, TViewer extends Viewer> implements PrivacyPolicyRule<TEnt, TViewer> {
     private id;
     private options;
-    constructor(id: ID, options: LoadEntOptions<T>);
-    apply(v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
+    constructor(id: ID, options: LoadEntOptions<TEnt, TViewer>);
+    apply(v: TViewer, _ent?: Ent): Promise<PrivacyResult>;
 }
-export declare class DenyIfEntIsNotVisibleRule<T extends Ent> implements PrivacyPolicyRule {
+export declare class DenyIfEntIsNotVisibleRule<TEnt extends Ent<TViewer>, TViewer extends Viewer> implements PrivacyPolicyRule {
     private id;
     private options;
-    constructor(id: ID, options: LoadEntOptions<T>);
-    apply(v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
+    constructor(id: ID, options: LoadEntOptions<TEnt, TViewer>);
+    apply(v: TViewer, _ent?: Ent): Promise<PrivacyResult>;
 }
 export declare class AllowIfEdgeExistsRule implements PrivacyPolicyRule {
     private id1;

package/core/query/assoc_query.d.ts

@@ -3,15 +3,15 @@ import { AssocEdge } from "../ent";
 import { AssocEdgeCountLoaderFactory } from "../loaders/assoc_count_loader";
 import { AssocEdgeLoaderFactory } from "../loaders/assoc_edge_loader";
 import { EdgeQuery, BaseEdgeQuery, IDInfo } from "./query";
-export declare type EdgeQuerySource<TSource extends Ent, TDest extends Ent = Ent> = TSource | TSource[] | ID | ID[] | EdgeQuery<TDest, Ent, AssocEdge>;
-declare type loaderOptionsFunc = (type: string) => LoadEntOptions<Ent>;
-export declare abstract class AssocEdgeQueryBase<TSource extends Ent, TDest extends Ent, TEdge extends AssocEdge> extends BaseEdgeQuery<TSource, TDest, TEdge> implements EdgeQuery<TSource, TDest, TEdge> {
-    viewer: Viewer;
-    src: EdgeQuerySource<TSource, TDest>;
+export declare type EdgeQuerySource<TSource extends Ent<TViewer>, TDest extends Ent<TViewer> = Ent<any>, TViewer extends Viewer = Viewer> = TSource | TSource[] | ID | ID[] | EdgeQuery<TDest, Ent, AssocEdge>;
+declare type loaderOptionsFunc<TViewer extends Viewer> = (type: string) => LoadEntOptions<Ent, TViewer>;
+export declare abstract class AssocEdgeQueryBase<TSource extends Ent<TViewer>, TDest extends Ent<TViewer>, TEdge extends AssocEdge, TViewer extends Viewer = Viewer> extends BaseEdgeQuery<TSource, TDest, TEdge> implements EdgeQuery<TSource, TDest, TEdge> {
+    viewer: TViewer;
+    src: EdgeQuerySource<TSource, TDest, TViewer>;
     private countLoaderFactory;
     private dataLoaderFactory;
     private options;
-    constructor(viewer: Viewer, src: EdgeQuerySource<TSource, TDest>, countLoaderFactory: AssocEdgeCountLoaderFactory, dataLoaderFactory: AssocEdgeLoaderFactory<TEdge>, options: LoadEntOptions<TDest> | loaderOptionsFunc);
+    constructor(viewer: TViewer, src: EdgeQuerySource<TSource, TDest, TViewer>, countLoaderFactory: AssocEdgeCountLoaderFactory, dataLoaderFactory: AssocEdgeLoaderFactory<TEdge>, options: LoadEntOptions<TDest, TViewer> | loaderOptionsFunc<TViewer>);
     private isEdgeQuery;
     abstract sourceEnt(id: ID): Promise<Ent | null>;
     private getSingleID;

package/core/query/custom_query.d.ts

@@ -1,17 +1,17 @@
 import { Data, Ent, ID, EdgeQueryableDataOptions, LoadEntOptions, Viewer, LoaderFactory, ConfigurableLoaderFactory } from "../base";
 import { BaseEdgeQuery, IDInfo, EdgeQuery } from "./query";
-export interface CustomEdgeQueryOptions<TSource extends Ent, TDest extends Ent> {
+export interface CustomEdgeQueryOptions<TSource extends Ent<TViewer>, TDest extends Ent<TViewer>, TViewer extends Viewer = Viewer> {
     src: TSource | ID;
     countLoaderFactory: LoaderFactory<ID, number>;
     dataLoaderFactory: ConfigurableLoaderFactory<ID, Data[]>;
-    options: LoadEntOptions<TDest>;
+    options: LoadEntOptions<TDest, TViewer>;
     sortColumn?: string;
 }
-export declare abstract class CustomEdgeQueryBase<TSource extends Ent, TDest extends Ent> extends BaseEdgeQuery<TSource, TDest, Data> implements EdgeQuery<TSource, TDest, Data> {
-    viewer: Viewer;
+export declare abstract class CustomEdgeQueryBase<TSource extends Ent<TViewer>, TDest extends Ent<TViewer>, TViewer extends Viewer = Viewer> extends BaseEdgeQuery<TSource, TDest, Data> implements EdgeQuery<TSource, TDest, Data> {
+    viewer: TViewer;
     private options;
     private id;
-    constructor(viewer: Viewer, options: CustomEdgeQueryOptions<TSource, TDest>);
+    constructor(viewer: TViewer, options: CustomEdgeQueryOptions<TSource, TDest, TViewer>);
     abstract sourceEnt(id: ID): Promise<Ent | null>;
     private idVisible;
     queryRawCount(): Promise<number>;

package/core/query/query.d.ts

@@ -41,7 +41,7 @@ export declare abstract class BaseEdgeQuery<TSource extends Ent, TDest extends E
     private idMap;
     private idsToFetch;
     constructor(viewer: Viewer, sortCol: string);
-    getPrivacyPolicy(): PrivacyPolicy<Ent>;
+    getPrivacyPolicy(): PrivacyPolicy<Ent<Viewer<Ent<any> | null, ID | null>>, Viewer<Ent<any> | null, ID | null>>;
     abstract sourceEnt(id: ID): Promise<Ent | null>;
     first(n: number, after?: string): this;
     last(n: number, before?: string): this;

package/core/viewer.d.ts

@@ -1,7 +1,7 @@
 import { ID, Ent, Viewer, Context } from "./base";
 export declare class LoggedOutViewer implements Viewer {
-    context?: Context | undefined;
-    constructor(context?: Context | undefined);
+    context?: Context<Viewer<Ent<any> | null, ID | null>> | undefined;
+    constructor(context?: Context<Viewer<Ent<any> | null, ID | null>> | undefined);
     viewerID: null;
     viewer(): Promise<null>;
     instanceKey(): string;
@@ -18,6 +18,6 @@ export declare class IDViewer implements Viewer {
     constructor(viewerID: ID, opts?: Partial<IDViewerOptions>);
     constructor(opts: IDViewerOptions);
     setContext(ctx: Context): this;
-    viewer(): Promise<Ent | null>;
+    viewer(): Promise<Ent<Viewer<Ent<any> | null, ID | null>> | null>;
     instanceKey(): string;
 }

package/graphql/query/edge_connection.d.ts

@@ -1,30 +1,30 @@
 import { EdgeQuery, PaginationInfo } from "../../core/query/query";
-import { Data, Ent, Viewer } from "../../core/base";
+import { Data, Ent, ID, Viewer } from "../../core/base";
 export interface GraphQLEdge<T extends Data> {
     edge: T;
     node: Ent;
     cursor: string;
 }
-interface edgeQueryCtr<T extends Ent, TEdge extends Data> {
-    (v: Viewer, src: T): EdgeQuery<T, Ent, TEdge>;
+interface edgeQueryCtr<T extends Ent, TEdge extends Data, TViewer extends Viewer> {
+    (v: TViewer, src: T): EdgeQuery<T, Ent, TEdge>;
 }
-interface edgeQueryCtr2<T extends Ent, TEdge extends Data> {
-    (v: Viewer): EdgeQuery<T, Ent, TEdge>;
+interface edgeQueryCtr2<T extends Ent, TEdge extends Data, TViewer extends Viewer> {
+    (v: TViewer): EdgeQuery<T, Ent, TEdge>;
 }
-export declare class GraphQLEdgeConnection<TSource extends Ent, TEdge extends Data> {
+export declare class GraphQLEdgeConnection<TSource extends Ent, TEdge extends Data, TViewer extends Viewer = Viewer> {
     query: EdgeQuery<TSource, Ent, TEdge>;
     private results;
     private viewer;
     private source?;
     private args?;
-    constructor(viewer: Viewer, source: TSource, getQuery: edgeQueryCtr<TSource, TEdge>, args?: Data);
-    constructor(viewer: Viewer, getQuery: edgeQueryCtr2<TSource, TEdge>, args?: Data);
+    constructor(viewer: TViewer, source: TSource, getQuery: edgeQueryCtr<TSource, TEdge, TViewer>, args?: Data);
+    constructor(viewer: TViewer, getQuery: edgeQueryCtr2<TSource, TEdge, TViewer>, args?: Data);
     first(limit: number, cursor?: string): void;
     last(limit: number, cursor?: string): void;
     modifyQuery(fn: (query: EdgeQuery<TSource, Ent, TEdge>) => EdgeQuery<TSource, Ent, TEdge>): void;
     queryTotalCount(): Promise<number>;
     queryEdges(): Promise<GraphQLEdge<TEdge>[]>;
-    queryNodes(): Promise<Ent[]>;
+    queryNodes(): Promise<Ent<Viewer<Ent<any> | null, ID | null>>[]>;
     private defaultPageInfo;
     queryPageInfo(): Promise<PaginationInfo>;
     private queryData;

package/graphql/query/page_info.d.ts

@@ -1,4 +1,4 @@
 import { GraphQLObjectType } from "graphql";
 import { RequestContext } from "../../core/context";
 import { PaginationInfo } from "../../core/query/query";
-export declare const GraphQLPageInfo: GraphQLObjectType<PaginationInfo, RequestContext>;
+export declare const GraphQLPageInfo: GraphQLObjectType<PaginationInfo, RequestContext<import("../..").Viewer<import("../..").Ent<any> | null, import("../..").ID | null>>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowtop/ent",
-  "version": "0.1.0-alpha13",
+  "version": "0.1.0-alpha16",
   "description": "snowtop ent framework",
   "main": "index.js",
   "types": "index.d.ts",

package/parse_schema/parse.d.ts

@@ -24,6 +24,7 @@ declare type ProcessedSchema = Omit<Schema, "edges" | "actions" | "edgeGroups" |
     assocEdgeGroups: ProcessedAssocEdgeGroup[];
     fields: ProcessedField[];
     schemaPath?: string;
+    patternNames?: string[];
 };
 declare type ProcessedAssocEdgeGroup = Omit<AssocEdgeGroup, "edgeAction"> & {
     edgeAction?: OutputAction;
@@ -38,6 +39,7 @@ interface ProcessedPattern {
     name: string;
     assocEdges: ProcessedAssocEdge[];
     fields: ProcessedField[];
+    disableMixin?: boolean;
 }
 declare type ProcessedType = Omit<Type, "subFields" | "listElemType" | "unionFields"> & {
     subFields?: ProcessedField[];

package/parse_schema/parse.js

@@ -130,6 +130,7 @@ function processPattern(patterns, pattern, processedSchema) {
             name: pattern.name,
             assocEdges: edges,
             fields: fields,
+            disableMixin: pattern.disableMixin,
         };
     }
     else {
@@ -202,9 +203,11 @@ function parseSchema(potentialSchemas) {
         };
         // let's put patterns first just so we have id, created_at, updated_at first
         // ¯\_(ツ)_/¯
+        let patternNames = [];
         if (schema.patterns) {
             for (const pattern of schema.patterns) {
                 const ret = processPattern(patterns, pattern, processedSchema);
+                patternNames.push(pattern.name);
                 if (ret.transformsSelect) {
                     if (processedSchema.transformsSelect) {
                         throw new Error(`can only have one pattern which transforms default querying behavior`);
@@ -221,6 +224,7 @@ function parseSchema(potentialSchemas) {
         }
         const fields = processFields(schema.fields);
         processedSchema.fields.push(...fields);
+        processedSchema.patternNames = patternNames;
         if (schema.edges) {
             const edges = processEdges(schema.edges);
             processedSchema.assocEdges.push(...edges);

package/schema/base_schema.js

@@ -66,6 +66,7 @@ let nodeFieldsWithTZ = {
 exports.Node = {
     name: "node",
     fields: nodeFields,
+    disableMixin: true,
 };
 // Ent schema. has Node Pattern by default.
 // exists just to have less typing and easier for clients to implement
@@ -95,6 +96,7 @@ class EntSchemaWithTZ {
                 // default schema added
                 name: "nodeWithTZ",
                 fields: nodeFieldsWithTZ,
+                disableMixin: true,
             },
         ];
         this.fields = cfg.fields;
@@ -131,6 +133,7 @@ class BaseEntSchemaWithTZ {
                 // default schema added
                 name: "nodeWithTZ",
                 fields: nodeFieldsWithTZ,
+                disableMixin: true,
             },
         ];
     }

package/schema/schema.d.ts

@@ -69,6 +69,7 @@ export declare type Edge = AssocEdge;
 export interface Pattern {
     name: string;
     fields: FieldMap | Field[];
+    disableMixin?: boolean;
     edges?: Edge[];
     transformRead?: () => Clause;
     transformWrite?: <T extends Ent>(stmt: UpdateOperation<T>) => TransformedUpdateOperation<T> | null;

package/scripts/move_generated.js

@@ -122,12 +122,11 @@ function main() {
     (0, child_process_1.execSync)("prettier src/graphql/*.ts --write");
 }
 function isGeneratedPath(node, sourceFile, dirPath) {
-    const text = node.moduleSpecifier.getText(sourceFile).slice(1, -1);
     // it's relative and has generated in there, continue
-    if (!((text.startsWith("..") || text.startsWith("./")) &&
-        text.indexOf("/generated") !== -1)) {
+    if (!(0, ast_1.isRelativeGeneratedImport)(node, sourceFile)) {
         return;
     }
+    const text = node.moduleSpecifier.getText(sourceFile).slice(1, -1);
     const oldPath = path.join(dirPath, text);
     const relFromRoot = path.relative(".", oldPath);
     const conv = transformPath(relFromRoot);

package/scripts/transform_actions.d.ts

@@ -0,0 +1 @@
+export {};

package/scripts/transform_actions.js

@@ -0,0 +1,266 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const glob_1 = require("glob");
+const typescript_1 = __importDefault(require("typescript"));
+const compilerOptions_1 = require("../tsc/compilerOptions");
+const ast_1 = require("../tsc/ast");
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const action_1 = require("../action");
+const viewer_1 = require("../core/viewer");
+const path = __importStar(require("path"));
+const js_yaml_1 = require("js-yaml");
+function transformRelative(file, importPath, relative) {
+    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) {
+    if (p.endsWith("..")) {
+        return p + "/";
+    }
+    return p;
+}
+function findInput(file, sourceFile) {
+    // @ts-ignore
+    const importStatements = sourceFile.statements.filter((stmt) => typescript_1.default.isImportDeclaration(stmt));
+    for (const imp of importStatements) {
+        const text = imp.moduleSpecifier.getText(sourceFile).slice(1, -1);
+        if ((0, ast_1.isRelativeGeneratedImport)(imp, sourceFile)) {
+            // base file and we're importing from it
+            // e.g. in create_user_action, we're importing from create_user_action_base
+            if (path.basename(file).slice(0, -3) + "_base" !== path.basename(text)) {
+                continue;
+            }
+            const impInfo = (0, ast_1.getImportInfo)(imp, sourceFile);
+            if (!impInfo) {
+                continue;
+            }
+            const inputs = impInfo.imports
+                .filter((imp) => imp.trim() && imp.endsWith("Input"))
+                .map((v) => v.trim());
+            if (inputs.length === 1) {
+                return inputs[0];
+            }
+        }
+    }
+    return null;
+}
+function getCustomInfo() {
+    let yaml = {};
+    let relativeImports = false;
+    try {
+        yaml = (0, js_yaml_1.load)(fs.readFileSync(path.join(process.cwd(), "ent.yml"), {
+            encoding: "utf8",
+        }));
+        relativeImports = yaml?.codegen?.relativeImports || false;
+        if (yaml?.codegen?.templatizedViewer) {
+            return {
+                viewerInfo: yaml.codegen.templatizedViewer,
+                relativeImports,
+            };
+        }
+    }
+    catch (e) { }
+    return {
+        viewerInfo: {
+            path: "@snowtop/ent",
+            name: "Viewer",
+        },
+        relativeImports,
+    };
+}
+async function main() {
+    let files = glob_1.glob.sync("src/ent/**/actions/**/*_action.ts");
+    const target = (0, compilerOptions_1.getTargetFromCurrentDir)();
+    const customInfo = getCustomInfo();
+    const viewerInfo = customInfo.viewerInfo;
+    files.forEach((file) => {
+        let { contents, sourceFile } = (0, compilerOptions_1.createSourceFile)(target, file);
+        let traversed = false;
+        let nodes = [];
+        // require action
+        const p = require(path.join(process.cwd(), "./" + file.slice(0, -3)));
+        const action = new p.default(new viewer_1.LoggedOutViewer(), {});
+        const builder = action.builder.constructor.name;
+        const nodeName = action.builder.ent.name;
+        const existingEnt = action.builder.operation === action_1.WriteOperation.Insert
+            ? `${nodeName} | null`
+            : nodeName;
+        const viewer = customInfo.viewerInfo.name;
+        const input = findInput(file, sourceFile);
+        if (!input) {
+            return;
+        }
+        let newImports = [];
+        typescript_1.default.forEachChild(sourceFile, function (node) {
+            if (!typescript_1.default.isClassDeclaration(node) || !node.heritageClauses) {
+                nodes.push({ node });
+                return;
+            }
+            let classInfo = (0, ast_1.getClassInfo)(contents, sourceFile, node);
+            // only do classes
+            if (!classInfo) {
+                return;
+            }
+            let klassContents = "";
+            for (const mm of node.members) {
+                const conv = getConversionInfo(mm);
+                if (conv !== null) {
+                    const property = mm;
+                    // if invalid, bounce
+                    if (!property.initializer) {
+                        traversed = false;
+                        return;
+                    }
+                    traversed = true;
+                    const pp = property.initializer.getFullText(sourceFile).trim();
+                    const code = `${conv.method}(): ${conv.interface}<${nodeName}, ${builder}<${input}, ${existingEnt}>, ${viewer}, ${input}, ${existingEnt}>[] {
+            return ${pp}
+          }`;
+                    newImports.push(conv.interface);
+                    klassContents += (0, ast_1.getPreText)(contents, mm, sourceFile) + code;
+                }
+                else {
+                    klassContents += mm.getFullText(sourceFile);
+                }
+            }
+            // wrap comments and transform to export class Foo extends Bar { ${inner} }
+            nodes.push({ rawString: classInfo.wrapClassContents(klassContents) });
+        });
+        // if traversed, overwrite.
+        if (!traversed) {
+            return;
+        }
+        let newContents = "";
+        let afterProcessed = false;
+        let imports = new Map([
+            [
+                transformRelative(file, viewerInfo.path, customInfo.relativeImports),
+                [viewer],
+            ],
+            [
+                transformRelative(file, "src/ent", customInfo.relativeImports),
+                [nodeName],
+            ],
+            ["@snowtop/ent/action", newImports],
+        ]);
+        let seen = new Map();
+        const processAfterImport = () => {
+            // do this for the first non-import node we see
+            // we want to add new imports to end of imports and there's an assumption that imports are ordered
+            // at top of file
+            if (!afterProcessed) {
+                for (const [imp, list] of imports) {
+                    if (seen.has(imp)) {
+                        continue;
+                    }
+                    newContents += `\nimport { ${list.join(", ")} } from "${imp}"`;
+                }
+                afterProcessed = true;
+            }
+        };
+        for (const node of nodes) {
+            if (node.node) {
+                if (typescript_1.default.isImportDeclaration(node.node)) {
+                    const impInfo = (0, ast_1.getImportInfo)(node.node, sourceFile);
+                    if (impInfo) {
+                        const impPath = normalizePath(impInfo.importPath);
+                        // normalize paths...
+                        const list = imports.get(impPath);
+                        if (list) {
+                            let transformed = (0, ast_1.transformImport)(contents, node.node, sourceFile, {
+                                newImports: list,
+                                // don't use normalized path here, we wanna use the path that's in code...
+                                transformPath: impInfo.importPath,
+                            });
+                            if (transformed) {
+                                newContents += transformed;
+                                seen.set(impPath, true);
+                                continue;
+                            }
+                        }
+                    }
+                }
+                else {
+                    if (!typescript_1.default.isExportDeclaration(node.node)) {
+                        processAfterImport();
+                    }
+                }
+                newContents += node.node.getFullText(sourceFile);
+            }
+            else if (node.rawString) {
+                processAfterImport();
+                newContents += node.rawString;
+            }
+            else {
+                throw new Error(`malformed node with no node or rawString`);
+            }
+            fs.writeFileSync(file, newContents);
+        }
+    });
+    (0, child_process_1.execSync)("prettier src/ent/**/actions/**/*.ts --write");
+}
+let m = {
+    triggers: {
+        m: "getTriggers",
+        i: "Trigger",
+    },
+    observers: {
+        m: "getObservers",
+        i: "Observer",
+    },
+    validators: {
+        m: "getValidators",
+        i: "Validator",
+    },
+};
+function getConversionInfo(mm) {
+    if (mm.kind !== typescript_1.default.SyntaxKind.PropertyDeclaration) {
+        return null;
+    }
+    const text = mm.name.escapedText;
+    const v = m[text];
+    if (v === undefined) {
+        return null;
+    }
+    return {
+        text,
+        method: v.m,
+        interface: v.i,
+    };
+}
+main()
+    .then(() => {
+    process.exit(0);
+})
+    .catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/scripts/transform_code.js

@@ -45,7 +45,6 @@ async function main() {
             if (!classInfo || classInfo.extends !== classInfo.name + "Base") {
                 return;
             }
-            // need to check for PrivacyPolicy import...
             traversed = true;
             let klassContents = "";
             for (const mm of node.members) {
@@ -60,7 +59,7 @@ async function main() {
                     const code = `getPrivacyPolicy(): PrivacyPolicy<this> {
             return ${pp}
           }`;
-                    klassContents += code;
+                    klassContents += (0, ast_1.getPreText)(contents, mm, sourceFile) + code;
                 }
                 else {
                     klassContents += mm.getFullText(sourceFile);
@@ -68,7 +67,6 @@ async function main() {
             }
             // wrap comments and transform to export class Foo extends Bar { ${inner} }
             nodes.push({ rawString: classInfo.wrapClassContents(klassContents) });
-            //      console.debug(classInfo.wrapClassContents(klassContents));
         });
         // if traversed, overwrite.
         if (!traversed) {

package/testutils/builder.d.ts

@@ -77,12 +77,13 @@ export declare class SimpleBuilder<T extends Ent, TExistingEnt extends TMaybleNu
     existingEnt: TExistingEnt;
     ent: EntConstructor<T>;
     placeholderID: ID;
-    orchestrator: Orchestrator<T, Data>;
+    orchestrator: Orchestrator<T, Data, Viewer>;
     fields: Map<string, any>;
     nodeType: string;
-    constructor(viewer: Viewer, schema: BuilderSchema<T>, fields: Map<string, any>, operation: WriteOperation, existingEnt: TExistingEnt, action?: Action<T, SimpleBuilder<T>, Data> | undefined);
+    constructor(viewer: Viewer, schema: BuilderSchema<T>, fields: Map<string, any>, operation: WriteOperation, existingEnt: TExistingEnt, action?: Action<T, SimpleBuilder<T>, Viewer, Data> | undefined);
+    getInput(): Data;
     updateInput(input: Data): void;
-    build(): Promise<Changeset<T>>;
+    build(): Promise<Changeset>;
     editedEnt(): Promise<T | null>;
     editedEntX(): Promise<T>;
     save(): Promise<void>;
@@ -93,18 +94,18 @@ export declare class SimpleBuilder<T extends Ent, TExistingEnt extends TMaybleNu
 interface viewerEntLoadFunc {
     (data: Data): Viewer | Promise<Viewer>;
 }
-export declare class SimpleAction<T extends Ent, TExistingEnt extends TMaybleNullableEnt<T> = MaybeNull<T>> implements Action<T, SimpleBuilder<T, TExistingEnt>, Data, TExistingEnt> {
+export declare class SimpleAction<T extends Ent, TExistingEnt extends TMaybleNullableEnt<T> = MaybeNull<T>> implements Action<T, SimpleBuilder<T, TExistingEnt>, Viewer, Data, TExistingEnt> {
     viewer: Viewer;
     private fields;
     builder: SimpleBuilder<T, TExistingEnt>;
-    validators: Validator<T, SimpleBuilder<T>, Data>[];
-    triggers: Trigger<T, SimpleBuilder<T>, Data>[];
-    observers: Observer<T, SimpleBuilder<T>, Data>[];
     viewerForEntLoad: viewerEntLoadFunc | undefined;
     constructor(viewer: Viewer, schema: BuilderSchema<T>, fields: Map<string, any>, operation: WriteOperation | undefined, existingEnt: TExistingEnt);
-    getPrivacyPolicy(): PrivacyPolicy<Ent>;
+    getTriggers(): Trigger<T, SimpleBuilder<T>>[];
+    getValidators(): Validator<T, SimpleBuilder<T>>[];
+    getObservers(): Observer<T, SimpleBuilder<T>>[];
+    getPrivacyPolicy(): PrivacyPolicy<Ent<Viewer<Ent<any> | null, ID | null>>, Viewer<Ent<any> | null, ID | null>>;
     getInput(): Data;
-    changeset(): Promise<Changeset<T>>;
+    changeset(): Promise<Changeset>;
     valid(): Promise<boolean>;
     validX(): Promise<void>;
     save(): Promise<T | null>;