@hpcc-js/marshaller 2.28.7 → 2.28.8

package/src/ddl2/activities/rest.ts

@@ -1,568 +1,568 @@
-import { PropertyExt, publish } from "@hpcc-js/common";
-import { createConnection } from "@hpcc-js/comms";
-import { DDL2 } from "@hpcc-js/ddl-shim";
-import { AsyncOrderedQueue, compare, hashSum } from "@hpcc-js/util";
-import { Element, ElementContainer } from "../model/element";
-import { IActivityError, ReferencedFields } from "./activity";
-import { rowToFields } from "./databomb";
-import { Datasource, DatasourceRef } from "./datasource";
-
-export class RestField extends PropertyExt {
-    protected _owner: RestService;
-
-    @publish("", "string", "RestField Label")
-    fieldID: publish<this, string>;
-
-    constructor() {
-        super();
-    }
-
-    toDDL(): DDL2.IFieldString {
-        return {
-            type: "string",
-            id: this.fieldID()
-        };
-    }
-
-    fromDDL(ddl: DDL2.IFieldString): this {
-        return this
-            .fieldID(ddl.id)
-            ;
-    }
-
-    static fromDDL(ddl: DDL2.IFieldString): RestField {
-        return new RestField().fromDDL(ddl);
-    }
-
-    owner(): RestService;
-    owner(_: RestService): this;
-    owner(_?: RestService): RestService | this {
-        if (!arguments.length) return this._owner;
-        this._owner = _;
-        return this;
-    }
-
-    valid(): boolean {
-        return !!this.fieldID();
-    }
-}
-
-export class RestService extends Datasource {
-
-    private _responseFields: { [outputID: string]: DDL2.IField[] } = {};
-
-    @publish("", "string", "REST Url")
-    url: publish<this, string>;
-    @publish("", "string", "Query Set")
-    action: publish<this, string>;
-    @publish("get", "set", "Request mode", ["get", "post"])
-    mode: publish<this, "get" | "post">;
-    @publish([], "propertyArray", "Multi Fields", null, { autoExpand: RestField })
-    requestFields: publish<this, RestField[]>;
-
-    constructor(readonly _ec: ElementContainer) {
-        super();
-    }
-
-    toDDL(): DDL2.IRestService {
-        return {
-            type: "rest",
-            id: this.id(),
-            url: this.url(),
-            action: this.action(),
-            mode: this.mode(),
-            inputs: this.validRequestFields().map(rf => rf.toDDL()),
-            outputs: this.outputDDL()
-        };
-    }
-
-    fromDDL(ddl: DDL2.IRestService, skipID = false): this {
-        (skipID ? this : this.id(ddl.id))
-            .url(ddl.url)
-            .action(ddl.action)
-            .mode(ddl.mode || "get")
-            .requestFields(ddl.inputs.map(RestField.fromDDL))
-            ;
-        for (const key in ddl.outputs) {
-            this.responseFields(key, ddl.outputs[key].fields);
-        }
-        return this;
-    }
-
-    static fromDDL(ec: ElementContainer, ddl: DDL2.IRestService, skipID = false): RestService {
-        return new RestService(ec).fromDDL(ddl, skipID);
-    }
-
-    hash(more: object = {}): string {
-        return hashSum({
-            url: this.url(),
-            action: this.action(),
-            mode: this.mode(),
-            ...more
-        });
-    }
-
-    label(): string {
-        return this.action();
-    }
-
-    responseFields(resultName: string): DDL2.IField[];
-    responseFields(resultName: string, _: DDL2.IField[]): this;
-    responseFields(resultName: string, _?: DDL2.IField[]): DDL2.IField[] | this {
-        if (arguments.length === 1) return this._responseFields[resultName] || [];
-        this._responseFields[resultName] = _;
-        return this;
-    }
-
-    validRequestFields(): RestField[] {
-        return this.requestFields().filter(f => f.valid());
-    }
-
-    private _prevRequestHash;
-    private _prevPromise;
-    private _submitQ = new AsyncOrderedQueue();
-    submit(request: { [key: string]: any }): Promise<{ [key: string]: any }> {
-        const requestHash = hashSum(request);
-        if (!this._prevPromise || this._prevRequestHash !== requestHash) {
-            this._prevRequestHash = requestHash;
-            const conn = createConnection({ baseUrl: this.url(), type: this.mode() });
-            this._prevPromise = this._submitQ.push(conn.send(this.action(), request));
-        }
-        return this._prevPromise;
-    }
-
-    resultNames(): string[] {
-        const retVal: string[] = [];
-        for (const key in this._responseFields) {
-            retVal.push(key);
-        }
-        return retVal;
-    }
-
-    outputDDL(): DDL2.OutputDict {
-        const retVal: DDL2.OutputDict = {};
-        this.resultNames().forEach(resultName => {
-            retVal[resultName] = {
-                fields: this._responseFields[resultName]
-            };
-        });
-        return retVal;
-    }
-}
-RestService.prototype._class += " RestService";
-
-export class RestResult extends Datasource {
-
-    @publish(null, "widget", "Rest service")
-    _service: RestService = new RestService(this._ec);
-    service(): RestService;
-    service(_: RestService): this;
-    service(_?: RestService): this | RestService {
-        if (!arguments.length) return this._service;
-        this._service = _;
-        this._service.refreshMeta();
-        return this;
-    }
-
-    @publish("", "string", "Result Name")
-    resultName: publish<this, string>;
-
-    constructor(private _ec: ElementContainer) {
-        super();
-    }
-
-    validRequestFields(): RestField[] {
-        return this.service().validRequestFields();
-    }
-
-    toDDL(): DDL2.IRestService {
-        return this.service().toDDL();
-    }
-
-    fromDDL(ddl: DDL2.IRestService): this {
-        this.service().fromDDL(ddl);
-        return this;
-    }
-
-    static fromDDL(ec: ElementContainer, rs: RestService, resultName: string): RestResult {
-        return new RestResult(ec)
-            .id(`${rs.id()}_${resultName}`)
-            .service(rs)
-            .resultName(resultName)
-            ;
-    }
-
-    serviceID(): string {
-        return `${this.service().url()}/${this.service().action()}}`;
-    }
-
-    sourceHash(): string {
-        return this.service().hash();
-    }
-
-    requestFields(): DDL2.IField[] {
-        return this.service().requestFields().map(rf => rf.toDDL());
-    }
-
-    responseFields(): DDL2.IField[];
-    responseFields(_: DDL2.IField[]): this;
-    responseFields(_?: DDL2.IField[]): this | DDL2.IField[] {
-        if (!arguments.length) return this.service().responseFields(this.resultName());
-        this.service().responseFields(this.resultName(), _);
-        return this;
-    }
-
-    hash(more: object = {}): string {
-        return hashSum({
-            source: this.sourceHash(),
-            resultName: this.resultName(),
-            ...more
-        });
-    }
-
-    label(): string {
-        return `${this.service().label()}\n${this.resultName()}`;
-    }
-
-    private _jsonData: object[] = [];
-    private jsonDataFields(): DDL2.IField[] {
-        if (!this._jsonData || !this._jsonData.length) return [];
-        const retVal = rowToFields(this._jsonData[0], this._jsonData);
-        this.responseFields(retVal);
-        return retVal;
-    }
-
-    computeFields(inFields: ReadonlyArray<DDL2.IField>): () => ReadonlyArray<DDL2.IField> {
-        return () => this.jsonDataFields();
-    }
-
-    computeData(): ReadonlyArray<object> {
-        return this._jsonData;
-    }
-
-    submit(request: { [key: string]: any }): Promise<{ [key: string]: any }> {
-        return this.service().submit(request).then(response => {
-            const resultName = this.resultName();
-            const resultFields = resultName ? resultName.split(".") : [];
-            for (const field of resultFields) {
-                response = (response || {})[field];
-            }
-            this._jsonData = response as object[];
-            return response;
-        });
-    }
-
-    formatRequest() {
-        const request = {};
-        this.service().validRequestFields().forEach(f => {
-            request[f.fieldID()] = "";
-        });
-        return request;
-    }
-
-    exec(): Promise<void> {
-        return this.submit(this.formatRequest()).then(response => { });
-    }
-}
-RestResult.prototype._class += " RestResult";
-
-export class Param extends PropertyExt {
-
-    @publish(null, "string", "Label")  //  TODO Add ReadOnly
-    localField: publish<this, string>;
-    localField_exists: () => boolean;
-    @publish(null, "set", "Activity", function (this: Param) { return this.visualizationIDs(); }, {
-        optional: true,
-        disable: (w: Param): boolean => w.value_exists(),
-        validate: (w: Param): boolean => w.source_disabled() || w.visualizationIDs().indexOf(w.source()) >= 0
-    })
-    source: publish<this, string>;
-    source_exists: () => boolean;
-    source_valid: () => boolean;
-    source_disabled: () => boolean;
-    @publish(null, "set", "Source Field", function (this: Param) { return this.sourceFields(); }, {
-        optional: true,
-        disable: (w: Param): boolean => !w.source_exists() || w.value_exists(),
-        validate: (w: Param): boolean => w.remoteField_disabled() || w.sourceFields().indexOf(w.remoteField()) >= 0
-    })
-    remoteField: publish<this, string>;
-    remoteField_exists: () => boolean;
-    remoteField_valid: () => boolean;
-    remoteField_disabled: () => boolean;
-    @publish(null, "string", "Static Value", null, {
-        optional: true,
-        disable: (w: Param): boolean => w.source_exists(),
-        validate: (w: Param): boolean => w.value_disabled() || w.value_exists()
-    })
-    value: publish<this, string>;
-    value_exists: () => boolean;
-    value_valid: () => boolean;
-    value_disabled: () => boolean;
-
-    validate(prefix: string): IActivityError[] {
-        const retVal: IActivityError[] = [];
-        if (!this.source_valid()) {
-            retVal.push({
-                source: `${prefix}.source.${this.source()}`,
-                msg: `Invalid source:  "${this.source()}"`,
-                hint: `expected:  ${JSON.stringify(this.visualizationIDs())}`
-            });
-        }
-        if (!this.remoteField_valid()) {
-            retVal.push({
-                source: `${prefix}.remoteField`,
-                msg: `Invalid remoteField:  "${this.remoteField()}"`,
-                hint: `expected:  ${JSON.stringify(this.sourceOutFields())}`
-            });
-        }
-        if (!this.value_valid()) {
-            retVal.push({
-                source: `${prefix}.value`,
-                msg: `Invalid value:  "${this.value()}"`,
-                hint: "expected:  any value."
-            });
-        }
-        return retVal;
-    }
-
-    constructor(private _ec: ElementContainer) {
-        super();
-    }
-
-    toDDL(): DDL2.IRequestField {
-        return {
-            source: this.source(),
-            remoteFieldID: this.remoteField(),
-            localFieldID: this.localField(),
-            value: this.value()
-        };
-    }
-
-    fromDDL(ddl: DDL2.IRequestField): this {
-        return this
-            .source(ddl.source)
-            .remoteField(ddl.remoteFieldID)
-            .localField(ddl.localFieldID)
-            .value(ddl.value)
-            ;
-    }
-
-    static fromDDL(ec: ElementContainer, ddl: DDL2.IRequestField): Param {
-        return new Param(ec).fromDDL(ddl);
-    }
-
-    hash() {
-        return hashSum({
-            label: this.localField(),
-            source: this.source(),
-            sourceField: this.remoteField()
-        });
-    }
-
-    visualizationIDs() {
-        return this._ec.elementIDs();
-    }
-
-    sourceFields() {
-        return this.sourceOutFields().map(field => field.id);
-    }
-
-    sourceViz(): Element {
-        return this._ec.element(this.source());
-    }
-
-    sourceOutFields(): ReadonlyArray<DDL2.IField> {
-        return this.sourceViz().hipiePipeline().selectionFields();
-    }
-
-    sourceSelection(): any[] {
-        return this.sourceViz().selection();
-    }
-
-    calcValue(): Array<string | number | boolean> {
-        if (this.source_exists() && this.remoteField_exists()) {
-            const sourceSelection = this.sourceSelection();
-            return sourceSelection.map(row => row[this.remoteField()]);
-        } else if (this.value_exists()) {
-            return [this.value()];
-        }
-        return [""];
-    }
-
-    exists(): boolean {
-        return this.localField_exists() && ((this.source_exists() && this.remoteField_exists()) || this.value_exists());
-    }
-}
-Param.prototype._class += " Param";
-
-export class RestResultRef extends DatasourceRef {
-
-    serviceID(): string {
-        return this.datasource().serviceID();
-    }
-
-    private _data: ReadonlyArray<object> = [];
-
-    datasource(): RestResult;
-    datasource(_: RestResult): this;
-    datasource(_?: RestResult): this | RestResult {
-        return super.datasource.apply(this, arguments);
-    }
-
-    url(): string {
-        return this.datasource().service().url();
-    }
-
-    action(): string {
-        return this.datasource().service().action();
-    }
-
-    resultName(): string {
-        return this.datasource().resultName();
-    }
-
-    @publish([], "propertyArray", "Request Fields")
-    _request: Param[];
-    request(): Param[];
-    request(_: Param[]): this;
-    request(_?: Param[]): Param[] | this {
-        if (!arguments.length) return this._request;
-        this._request = _;
-        return this;
-    }
-
-    validate(): IActivityError[] {
-        let retVal: IActivityError[] = [];
-        for (const filter of this.validParams()) {
-            retVal = retVal.concat(filter.validate("request"));
-        }
-        return retVal;
-    }
-
-    constructor(private _ec: ElementContainer) {
-        super();
-    }
-
-    toDDL(): DDL2.IRoxieServiceRef {
-        return {
-            id: this.datasource().service().id(),
-            output: this.resultName(),
-            request: this.validParams().map((vp): DDL2.IRequestField => {
-                return {
-                    source: vp.source(),
-                    remoteFieldID: vp.remoteField(),
-                    localFieldID: vp.localField(),
-                    value: vp.value()
-                };
-            })
-        };
-    }
-
-    sourceHash(): string {
-        return this.datasource().hash();
-    }
-
-    requestFieldRefs(): DDL2.IRequestField[];
-    requestFieldRefs(_: DDL2.IRequestField[]): this;
-    requestFieldRefs(_?: DDL2.IRequestField[]): DDL2.IRequestField[] | this {
-        if (!arguments.length) return this.validParams().map(param => param.toDDL());
-        this.request(_.map(fc => Param.fromDDL(this._ec, fc)));
-        return this;
-    }
-
-    requestFields(): DDL2.IField[] {
-        return this.datasource().requestFields();
-    }
-
-    responseFields(): DDL2.IField[] {
-        return this.datasource().responseFields();
-    }
-
-    hash(): string {
-        return this.datasource().hash({
-            resultName: this.resultName(),
-            request: this.formatRequest()
-        });
-    }
-
-    label(): string {
-        return `${this.datasource().label()}\n${this.datasource().resultName()}`;
-    }
-
-    elementIDs() {
-        return this._ec.elementIDs();
-    }
-
-    element(source) {
-        return this._ec.element(source);
-    }
-
-    referencedFields(refs: ReferencedFields): void {
-        super.referencedFields(refs);
-        const localFieldIDs: string[] = [];
-        for (const param of this.validParams()) {
-            const filterSource = param.sourceViz().hipiePipeline();
-            if (!refs.inputs[this.id()]) {
-                refs.inputs[this.id()] = [];
-            }
-            refs.inputs[this.id()].push(param.localField());
-            filterSource.resolveFields(refs, [param.remoteField()]);
-        }
-        super.resolveFields(refs, localFieldIDs);
-    }
-
-    validParams() {
-        return this.request().filter(param => param.exists());
-    }
-
-    refreshMeta(): Promise<void> {
-        return this.datasource().refreshMeta().then(() => {
-            const oldParams = this.request();
-            const diffs = compare(oldParams.map(p => p.localField()), this.datasource().validRequestFields().map(ff => ff.fieldID()));
-            const newParams = oldParams.filter(op => diffs.update.indexOf(op.localField()) >= 0);
-            this.request(newParams.concat(diffs.enter.map(label => new Param(this._ec).localField(label))));
-        });
-    }
-
-    updatedBy(): string[] {
-        return this.validParams().map(param => param.source());
-    }
-
-    computeFields(inFields: ReadonlyArray<DDL2.IField>): () => ReadonlyArray<DDL2.IField> {
-        return this.datasource().computeFields(inFields);
-    }
-
-    formatRequest(): { [key: string]: any } {
-        const request = this.datasource().formatRequest();
-        this.request().forEach(f => {
-            if (request[f.localField()] !== undefined) {
-                request[f.localField()] = f.calcValue() || request[f.localField()];
-            }
-        });
-        return request;
-    }
-
-    private _prevRequestHash;
-    private _prevRequestPromise;
-    exec(): Promise<void> {
-        const request = this.formatRequest();
-        const requestHash = hashSum({ hash: this.hash(), request });
-        if (this._prevRequestHash !== requestHash) {
-            this._prevRequestHash = requestHash;
-            this._prevRequestPromise = this.datasource().submit(request).then((response: { [key: string]: any }) => {
-                this._data = this.fixInt64(response);
-                return this._data;
-            });
-        }
-        return this._prevRequestPromise;
-    }
-
-    inData(): ReadonlyArray<object> {
-        return this._data;
-    }
-
-    computeData(): ReadonlyArray<object> {
-        return this._data;
-    }
-}
-RestResultRef.prototype._class += " RestResultRef";
+import { PropertyExt, publish } from "@hpcc-js/common";
+import { createConnection } from "@hpcc-js/comms";
+import { DDL2 } from "@hpcc-js/ddl-shim";
+import { AsyncOrderedQueue, compare, hashSum } from "@hpcc-js/util";
+import { Element, ElementContainer } from "../model/element";
+import { IActivityError, ReferencedFields } from "./activity";
+import { rowToFields } from "./databomb";
+import { Datasource, DatasourceRef } from "./datasource";
+
+export class RestField extends PropertyExt {
+    protected _owner: RestService;
+
+    @publish("", "string", "RestField Label")
+    fieldID: publish<this, string>;
+
+    constructor() {
+        super();
+    }
+
+    toDDL(): DDL2.IFieldString {
+        return {
+            type: "string",
+            id: this.fieldID()
+        };
+    }
+
+    fromDDL(ddl: DDL2.IFieldString): this {
+        return this
+            .fieldID(ddl.id)
+            ;
+    }
+
+    static fromDDL(ddl: DDL2.IFieldString): RestField {
+        return new RestField().fromDDL(ddl);
+    }
+
+    owner(): RestService;
+    owner(_: RestService): this;
+    owner(_?: RestService): RestService | this {
+        if (!arguments.length) return this._owner;
+        this._owner = _;
+        return this;
+    }
+
+    valid(): boolean {
+        return !!this.fieldID();
+    }
+}
+
+export class RestService extends Datasource {
+
+    private _responseFields: { [outputID: string]: DDL2.IField[] } = {};
+
+    @publish("", "string", "REST Url")
+    url: publish<this, string>;
+    @publish("", "string", "Query Set")
+    action: publish<this, string>;
+    @publish("get", "set", "Request mode", ["get", "post"])
+    mode: publish<this, "get" | "post">;
+    @publish([], "propertyArray", "Multi Fields", null, { autoExpand: RestField })
+    requestFields: publish<this, RestField[]>;
+
+    constructor(readonly _ec: ElementContainer) {
+        super();
+    }
+
+    toDDL(): DDL2.IRestService {
+        return {
+            type: "rest",
+            id: this.id(),
+            url: this.url(),
+            action: this.action(),
+            mode: this.mode(),
+            inputs: this.validRequestFields().map(rf => rf.toDDL()),
+            outputs: this.outputDDL()
+        };
+    }
+
+    fromDDL(ddl: DDL2.IRestService, skipID = false): this {
+        (skipID ? this : this.id(ddl.id))
+            .url(ddl.url)
+            .action(ddl.action)
+            .mode(ddl.mode || "get")
+            .requestFields(ddl.inputs.map(RestField.fromDDL))
+            ;
+        for (const key in ddl.outputs) {
+            this.responseFields(key, ddl.outputs[key].fields);
+        }
+        return this;
+    }
+
+    static fromDDL(ec: ElementContainer, ddl: DDL2.IRestService, skipID = false): RestService {
+        return new RestService(ec).fromDDL(ddl, skipID);
+    }
+
+    hash(more: object = {}): string {
+        return hashSum({
+            url: this.url(),
+            action: this.action(),
+            mode: this.mode(),
+            ...more
+        });
+    }
+
+    label(): string {
+        return this.action();
+    }
+
+    responseFields(resultName: string): DDL2.IField[];
+    responseFields(resultName: string, _: DDL2.IField[]): this;
+    responseFields(resultName: string, _?: DDL2.IField[]): DDL2.IField[] | this {
+        if (arguments.length === 1) return this._responseFields[resultName] || [];
+        this._responseFields[resultName] = _;
+        return this;
+    }
+
+    validRequestFields(): RestField[] {
+        return this.requestFields().filter(f => f.valid());
+    }
+
+    private _prevRequestHash;
+    private _prevPromise;
+    private _submitQ = new AsyncOrderedQueue();
+    submit(request: { [key: string]: any }): Promise<{ [key: string]: any }> {
+        const requestHash = hashSum(request);
+        if (!this._prevPromise || this._prevRequestHash !== requestHash) {
+            this._prevRequestHash = requestHash;
+            const conn = createConnection({ baseUrl: this.url(), type: this.mode() });
+            this._prevPromise = this._submitQ.push(conn.send(this.action(), request));
+        }
+        return this._prevPromise;
+    }
+
+    resultNames(): string[] {
+        const retVal: string[] = [];
+        for (const key in this._responseFields) {
+            retVal.push(key);
+        }
+        return retVal;
+    }
+
+    outputDDL(): DDL2.OutputDict {
+        const retVal: DDL2.OutputDict = {};
+        this.resultNames().forEach(resultName => {
+            retVal[resultName] = {
+                fields: this._responseFields[resultName]
+            };
+        });
+        return retVal;
+    }
+}
+RestService.prototype._class += " RestService";
+
+export class RestResult extends Datasource {
+
+    @publish(null, "widget", "Rest service")
+    _service: RestService = new RestService(this._ec);
+    service(): RestService;
+    service(_: RestService): this;
+    service(_?: RestService): this | RestService {
+        if (!arguments.length) return this._service;
+        this._service = _;
+        this._service.refreshMeta();
+        return this;
+    }
+
+    @publish("", "string", "Result Name")
+    resultName: publish<this, string>;
+
+    constructor(private _ec: ElementContainer) {
+        super();
+    }
+
+    validRequestFields(): RestField[] {
+        return this.service().validRequestFields();
+    }
+
+    toDDL(): DDL2.IRestService {
+        return this.service().toDDL();
+    }
+
+    fromDDL(ddl: DDL2.IRestService): this {
+        this.service().fromDDL(ddl);
+        return this;
+    }
+
+    static fromDDL(ec: ElementContainer, rs: RestService, resultName: string): RestResult {
+        return new RestResult(ec)
+            .id(`${rs.id()}_${resultName}`)
+            .service(rs)
+            .resultName(resultName)
+            ;
+    }
+
+    serviceID(): string {
+        return `${this.service().url()}/${this.service().action()}}`;
+    }
+
+    sourceHash(): string {
+        return this.service().hash();
+    }
+
+    requestFields(): DDL2.IField[] {
+        return this.service().requestFields().map(rf => rf.toDDL());
+    }
+
+    responseFields(): DDL2.IField[];
+    responseFields(_: DDL2.IField[]): this;
+    responseFields(_?: DDL2.IField[]): this | DDL2.IField[] {
+        if (!arguments.length) return this.service().responseFields(this.resultName());
+        this.service().responseFields(this.resultName(), _);
+        return this;
+    }
+
+    hash(more: object = {}): string {
+        return hashSum({
+            source: this.sourceHash(),
+            resultName: this.resultName(),
+            ...more
+        });
+    }
+
+    label(): string {
+        return `${this.service().label()}\n${this.resultName()}`;
+    }
+
+    private _jsonData: object[] = [];
+    private jsonDataFields(): DDL2.IField[] {
+        if (!this._jsonData || !this._jsonData.length) return [];
+        const retVal = rowToFields(this._jsonData[0], this._jsonData);
+        this.responseFields(retVal);
+        return retVal;
+    }
+
+    computeFields(inFields: ReadonlyArray<DDL2.IField>): () => ReadonlyArray<DDL2.IField> {
+        return () => this.jsonDataFields();
+    }
+
+    computeData(): ReadonlyArray<object> {
+        return this._jsonData;
+    }
+
+    submit(request: { [key: string]: any }): Promise<{ [key: string]: any }> {
+        return this.service().submit(request).then(response => {
+            const resultName = this.resultName();
+            const resultFields = resultName ? resultName.split(".") : [];
+            for (const field of resultFields) {
+                response = (response || {})[field];
+            }
+            this._jsonData = response as object[];
+            return response;
+        });
+    }
+
+    formatRequest() {
+        const request = {};
+        this.service().validRequestFields().forEach(f => {
+            request[f.fieldID()] = "";
+        });
+        return request;
+    }
+
+    exec(): Promise<void> {
+        return this.submit(this.formatRequest()).then(response => { });
+    }
+}
+RestResult.prototype._class += " RestResult";
+
+export class Param extends PropertyExt {
+
+    @publish(null, "string", "Label")  //  TODO Add ReadOnly
+    localField: publish<this, string>;
+    localField_exists: () => boolean;
+    @publish(null, "set", "Activity", function (this: Param) { return this.visualizationIDs(); }, {
+        optional: true,
+        disable: (w: Param): boolean => w.value_exists(),
+        validate: (w: Param): boolean => w.source_disabled() || w.visualizationIDs().indexOf(w.source()) >= 0
+    })
+    source: publish<this, string>;
+    source_exists: () => boolean;
+    source_valid: () => boolean;
+    source_disabled: () => boolean;
+    @publish(null, "set", "Source Field", function (this: Param) { return this.sourceFields(); }, {
+        optional: true,
+        disable: (w: Param): boolean => !w.source_exists() || w.value_exists(),
+        validate: (w: Param): boolean => w.remoteField_disabled() || w.sourceFields().indexOf(w.remoteField()) >= 0
+    })
+    remoteField: publish<this, string>;
+    remoteField_exists: () => boolean;
+    remoteField_valid: () => boolean;
+    remoteField_disabled: () => boolean;
+    @publish(null, "string", "Static Value", null, {
+        optional: true,
+        disable: (w: Param): boolean => w.source_exists(),
+        validate: (w: Param): boolean => w.value_disabled() || w.value_exists()
+    })
+    value: publish<this, string>;
+    value_exists: () => boolean;
+    value_valid: () => boolean;
+    value_disabled: () => boolean;
+
+    validate(prefix: string): IActivityError[] {
+        const retVal: IActivityError[] = [];
+        if (!this.source_valid()) {
+            retVal.push({
+                source: `${prefix}.source.${this.source()}`,
+                msg: `Invalid source:  "${this.source()}"`,
+                hint: `expected:  ${JSON.stringify(this.visualizationIDs())}`
+            });
+        }
+        if (!this.remoteField_valid()) {
+            retVal.push({
+                source: `${prefix}.remoteField`,
+                msg: `Invalid remoteField:  "${this.remoteField()}"`,
+                hint: `expected:  ${JSON.stringify(this.sourceOutFields())}`
+            });
+        }
+        if (!this.value_valid()) {
+            retVal.push({
+                source: `${prefix}.value`,
+                msg: `Invalid value:  "${this.value()}"`,
+                hint: "expected:  any value."
+            });
+        }
+        return retVal;
+    }
+
+    constructor(private _ec: ElementContainer) {
+        super();
+    }
+
+    toDDL(): DDL2.IRequestField {
+        return {
+            source: this.source(),
+            remoteFieldID: this.remoteField(),
+            localFieldID: this.localField(),
+            value: this.value()
+        };
+    }
+
+    fromDDL(ddl: DDL2.IRequestField): this {
+        return this
+            .source(ddl.source)
+            .remoteField(ddl.remoteFieldID)
+            .localField(ddl.localFieldID)
+            .value(ddl.value)
+            ;
+    }
+
+    static fromDDL(ec: ElementContainer, ddl: DDL2.IRequestField): Param {
+        return new Param(ec).fromDDL(ddl);
+    }
+
+    hash() {
+        return hashSum({
+            label: this.localField(),
+            source: this.source(),
+            sourceField: this.remoteField()
+        });
+    }
+
+    visualizationIDs() {
+        return this._ec.elementIDs();
+    }
+
+    sourceFields() {
+        return this.sourceOutFields().map(field => field.id);
+    }
+
+    sourceViz(): Element {
+        return this._ec.element(this.source());
+    }
+
+    sourceOutFields(): ReadonlyArray<DDL2.IField> {
+        return this.sourceViz().hipiePipeline().selectionFields();
+    }
+
+    sourceSelection(): any[] {
+        return this.sourceViz().selection();
+    }
+
+    calcValue(): Array<string | number | boolean> {
+        if (this.source_exists() && this.remoteField_exists()) {
+            const sourceSelection = this.sourceSelection();
+            return sourceSelection.map(row => row[this.remoteField()]);
+        } else if (this.value_exists()) {
+            return [this.value()];
+        }
+        return [""];
+    }
+
+    exists(): boolean {
+        return this.localField_exists() && ((this.source_exists() && this.remoteField_exists()) || this.value_exists());
+    }
+}
+Param.prototype._class += " Param";
+
+export class RestResultRef extends DatasourceRef {
+
+    serviceID(): string {
+        return this.datasource().serviceID();
+    }
+
+    private _data: ReadonlyArray<object> = [];
+
+    datasource(): RestResult;
+    datasource(_: RestResult): this;
+    datasource(_?: RestResult): this | RestResult {
+        return super.datasource.apply(this, arguments);
+    }
+
+    url(): string {
+        return this.datasource().service().url();
+    }
+
+    action(): string {
+        return this.datasource().service().action();
+    }
+
+    resultName(): string {
+        return this.datasource().resultName();
+    }
+
+    @publish([], "propertyArray", "Request Fields")
+    _request: Param[];
+    request(): Param[];
+    request(_: Param[]): this;
+    request(_?: Param[]): Param[] | this {
+        if (!arguments.length) return this._request;
+        this._request = _;
+        return this;
+    }
+
+    validate(): IActivityError[] {
+        let retVal: IActivityError[] = [];
+        for (const filter of this.validParams()) {
+            retVal = retVal.concat(filter.validate("request"));
+        }
+        return retVal;
+    }
+
+    constructor(private _ec: ElementContainer) {
+        super();
+    }
+
+    toDDL(): DDL2.IRoxieServiceRef {
+        return {
+            id: this.datasource().service().id(),
+            output: this.resultName(),
+            request: this.validParams().map((vp): DDL2.IRequestField => {
+                return {
+                    source: vp.source(),
+                    remoteFieldID: vp.remoteField(),
+                    localFieldID: vp.localField(),
+                    value: vp.value()
+                };
+            })
+        };
+    }
+
+    sourceHash(): string {
+        return this.datasource().hash();
+    }
+
+    requestFieldRefs(): DDL2.IRequestField[];
+    requestFieldRefs(_: DDL2.IRequestField[]): this;
+    requestFieldRefs(_?: DDL2.IRequestField[]): DDL2.IRequestField[] | this {
+        if (!arguments.length) return this.validParams().map(param => param.toDDL());
+        this.request(_.map(fc => Param.fromDDL(this._ec, fc)));
+        return this;
+    }
+
+    requestFields(): DDL2.IField[] {
+        return this.datasource().requestFields();
+    }
+
+    responseFields(): DDL2.IField[] {
+        return this.datasource().responseFields();
+    }
+
+    hash(): string {
+        return this.datasource().hash({
+            resultName: this.resultName(),
+            request: this.formatRequest()
+        });
+    }
+
+    label(): string {
+        return `${this.datasource().label()}\n${this.datasource().resultName()}`;
+    }
+
+    elementIDs() {
+        return this._ec.elementIDs();
+    }
+
+    element(source) {
+        return this._ec.element(source);
+    }
+
+    referencedFields(refs: ReferencedFields): void {
+        super.referencedFields(refs);
+        const localFieldIDs: string[] = [];
+        for (const param of this.validParams()) {
+            const filterSource = param.sourceViz().hipiePipeline();
+            if (!refs.inputs[this.id()]) {
+                refs.inputs[this.id()] = [];
+            }
+            refs.inputs[this.id()].push(param.localField());
+            filterSource.resolveFields(refs, [param.remoteField()]);
+        }
+        super.resolveFields(refs, localFieldIDs);
+    }
+
+    validParams() {
+        return this.request().filter(param => param.exists());
+    }
+
+    refreshMeta(): Promise<void> {
+        return this.datasource().refreshMeta().then(() => {
+            const oldParams = this.request();
+            const diffs = compare(oldParams.map(p => p.localField()), this.datasource().validRequestFields().map(ff => ff.fieldID()));
+            const newParams = oldParams.filter(op => diffs.update.indexOf(op.localField()) >= 0);
+            this.request(newParams.concat(diffs.enter.map(label => new Param(this._ec).localField(label))));
+        });
+    }
+
+    updatedBy(): string[] {
+        return this.validParams().map(param => param.source());
+    }
+
+    computeFields(inFields: ReadonlyArray<DDL2.IField>): () => ReadonlyArray<DDL2.IField> {
+        return this.datasource().computeFields(inFields);
+    }
+
+    formatRequest(): { [key: string]: any } {
+        const request = this.datasource().formatRequest();
+        this.request().forEach(f => {
+            if (request[f.localField()] !== undefined) {
+                request[f.localField()] = f.calcValue() || request[f.localField()];
+            }
+        });
+        return request;
+    }
+
+    private _prevRequestHash;
+    private _prevRequestPromise;
+    exec(): Promise<void> {
+        const request = this.formatRequest();
+        const requestHash = hashSum({ hash: this.hash(), request });
+        if (this._prevRequestHash !== requestHash) {
+            this._prevRequestHash = requestHash;
+            this._prevRequestPromise = this.datasource().submit(request).then((response: { [key: string]: any }) => {
+                this._data = this.fixInt64(response);
+                return this._data;
+            });
+        }
+        return this._prevRequestPromise;
+    }
+
+    inData(): ReadonlyArray<object> {
+        return this._data;
+    }
+
+    computeData(): ReadonlyArray<object> {
+        return this._data;
+    }
+}
+RestResultRef.prototype._class += " RestResultRef";