@mindline/sync 1.0.35 → 1.0.37

package/.vs/VSWorkspaceState.json

@@ -2,6 +2,5 @@
   "ExpandedNodes": [
     ""
   ],
-  "SelectedNode": "\\index.ts",
   "PreviewInSolutionExplorer": false
 }

package/hybridspa.ts

@@ -36,11 +36,17 @@ export const graphConfig = {
     graphGroupsEndpoint: "https://graph.microsoft.com/v1.0/groups",
     graphMailEndpoint: "https://graph.microsoft.com/v1.0/me/messages",
     graphMeEndpoint: "https://graph.microsoft.com/v1.0/me",
-    graphTenantByDomainEndpoint:
-        "https://graph.microsoft.com/beta/tenantRelationships/findTenantInformationByDomainName",
-    graphTenantByIdEndpoint:
-        "https://graph.microsoft.com/beta/tenantRelationships/findTenantInformationByTenantId",
     graphUsersEndpoint: "https://graph.microsoft.com/v1.0/users",
+    // sovereign cloud tenant info endpoints
+    graphTenantByDomainPredicate: "beta/tenantRelationships/findTenantInformationByDomainName",
+    graphTenantByIdPredicate:     "beta/tenantRelationships/findTenantInformationByTenantId",
+    // authority values are based on the well-known OIDC auth endpoints
+    authorityWW: "https://login.microsoftonline.com/",
+    authorityWWRegex: /^(https:\/\/login\.microsoftonline\.(?:us|com)\/)([\dA-Fa-f]{8}-[\dA-Fa-f]{4}-[\dA-Fa-f]{4}-[\dA-Fa-f]{4}-[\dA-Fa-f]{12})\/oauth2\/authorize$/,
+    authorityUS: "https://login.microsoftonline.us/",
+    authorityUSRegex: /^(https:\/\/login\.microsoftonline\.(?:us|com)\/)([\dA-Fa-f]{8}-[\dA-Fa-f]{4}-[\dA-Fa-f]{4}-[\dA-Fa-f]{4}-[\dA-Fa-f]{12})\/oauth2\/authorize$/,
+    authorityCN: "https://login.partner.microsoftonline.cn/",
+    authorityCNRegex: /^(https:\/\/login\.partner\.microsoftonline\.cn\/)([\dA-Fa-f]{8}-[\dA-Fa-f]{4}-[\dA-Fa-f]{4}-[\dA-Fa-f]{4}-[\dA-Fa-f]{12})\/oauth2\/authorize$/,
     // reader endpoint to trigger sync start
     readerStartSyncEndpoint: "https://dev-fn-reader-westus.azurewebsites.net/api/startSync/",
     readerApiEndpoint: "https://dev-fn-reader-westus.azurewebsites.net/api/lookup/"
@@ -215,20 +221,9 @@ export async function adminPost(
     workspaceId: string
 ): Promise<APIResult> {
     let result: APIResult = new APIResult();
-    if (
-        user.mail == null ||
-        user.mail === "" ||
-        user.authority == null ||
-        user.authority === "" ||
-        user.tid == null ||
-        user.tid === "" ||
-        user.companyName == null ||
-        user.companyName === "" ||
-        user.companyDomain == null ||
-        user.companyDomain === ""
-    ) {
+    if (user.mail == "" || user.authority == "" || user.tid === "") {
         result.result = false;
-        result.error = "configPost: invalid config ID";
+        result.error = "adminPost: invalid argument";
         result.status = 500;
         return result;
     }
@@ -863,14 +858,12 @@ export async function readerPost(
         return result;
     }
     // create reader endpoint with config ID
-    //let readerEndpoint: string = graphConfig.readerStartSyncEndpoint + config.id;
-    let readerEndpoint: string = graphConfig.readerApiEndpoint + config.id;
+    let readerEndpoint: string = graphConfig.readerStartSyncEndpoint + config.id;
     // create headers
     const headers = await defineHeaders(instance, authorizedUser);
     // make reader endpoint call
     let options = { method: "POST", headers: headers };
     try {
-        debugger;
         console.log("Attempting POST to /startSync: " + readerEndpoint);
         let response = await fetch(readerEndpoint, options);
         if (response.status === 200 && response.statusText === "OK") {

package/index.d.ts

@@ -1,187 +1,188 @@
 import { IPublicClientApplication } from "@azure/msal-browser";
 
 declare module "@mindline/sync" {
-  export function sum(a: number, b: number): number;
-  export function helloNpm(): string;
+    export function sum(a: number, b: number): number;
+    export function helloNpm(): string;
 
-  export class Group {
-    id: string;
-    displayName: string;
-    description: string;
-  }
-  // admin
-  export class User {
-    oid: string;  // from AAD ID token
-    name: string; // from AAD ID token
-    mail: string; // from AAD ID token TODO: preferred_username *may* differ from UPN, may differ from mail
-    authority: string; // from AAD auth response - cloud instance login endpoint
-    tid: string;  // from AAD ID token
-    companyName: string;    // findTenantInformationByTenantId TODO: process changes to company name
-    companyDomain: string;  // findTenantInformationByTenantId TODO: process changes to company name
-    associatedWorkspaces: string[];
-    workspaceIDs: string;
-    session: string;
-    spacode: string;
-    accessToken: string;
-    loginHint: string;
-    scopes: string[];
-    authTS: Date;
-    constructor();
-  }
-  // tenant (Azure AD tenant, AD domain, Google workspace)
-  export enum TenantType {
-    invalid = 0,
-    aad = 1,
-    ad = 2,
-    googleworkspace = 3
-  }
-  type TenantTypeStrings = keyof typeof TenantType;
-  export enum TenantPermissionType {
-    read = 1,
-    write = 2,
-    notassigned = 3
-  }
-  type TenantPermissionTypeStrings = keyof typeof TenantPermissionType;
-  export class Tenant {
-    tid: string; // from AAD ID token
-    name: string; // findTenantInformationByTenantId
-    domain: string; // findTenantInformationByTenantId
-    tenantType: TenantTypeStrings; // always "aad" for now
-    permissionType: TenantPermissionTypeStrings; // read/write/notassigned
-    onboarded: string;  // have we onboarded this tenant? "true" or "false"
-    authority: string;  // from AAD ID auth response
-    readServicePrincipal: string; // from AAD consent
-    writeServicePrincipal: string; // from AAD consent
-    workspaceIDs: string;
-    constructor();
-  }
-  // config
-  export enum TenantConfigType {
-    source = 1,
-    target = 2,
-    sourcetarget = 3
-  }
-  export type TenantConfigTypeStrings = keyof typeof TenantConfigType;
-  export class TenantConfigInfo {
-      tid: string;              // tenant identifier
-      sourceGroupId: string;    // source group - we can configure source group for reading
-      sourceGroupName: string;  // source group - we can configure source group for reading
-      configurationTenantType: TenantConfigTypeStrings;
-      deltaToken: string;
-      filesWritten: number;
-  }
-  export class Config {
-    id: string;
-    workspaceId: string;
-    name: string;
-    description: string;
-    tenants: TenantConfigInfo[];
-    isEnabled: boolean;
-    workspaceIDs: string;
-    constructor();
-  }
-  // class to group Users, Tenants, and Configs
-  export class Workspace {
-    id: string;
-    name: string;
-    associatedUsers: string[];
-    associatedTenants: string[];
-    associatedConfigs: string[];
-    constructor();
-  }
-  export class InitInfo {
-    us: User[];
-    ts: Tenant[];
-    cs: Config[];
-    ws: Workspace[];
-    constructor(bClearLocalStorage: boolean);
-    init(bClearLocalStorage: boolean): void;
-    save(): void;
-    tagWithWorkspaces(): boolean;
-  }
-  export type TaskType = "initialization" | 
+    export class Group {
+        id: string;
+        displayName: string;
+        description: string;
+    }
+    // admin
+    export class User {
+        oid: string;  // from AAD ID token
+        name: string; // from AAD ID token
+        mail: string; // from AAD ID token TODO: preferred_username *may* differ from UPN, may differ from mail
+        authority: string; // from AAD auth response - cloud instance login endpoint
+        tid: string;  // from AAD ID token
+        companyName: string;    // findTenantInformationByTenantId TODO: process changes to company name
+        companyDomain: string;  // findTenantInformationByTenantId TODO: process changes to company name
+        associatedWorkspaces: string[];
+        workspaceIDs: string;
+        session: string;
+        spacode: string;
+        accessToken: string;
+        loginHint: string;
+        scopes: string[];
+        authTS: Date;
+        constructor();
+    }
+    // tenant (Azure AD tenant, AD domain, Google workspace)
+    export enum TenantType {
+        invalid = 0,
+        aad = 1,
+        ad = 2,
+        googleworkspace = 3
+    }
+    type TenantTypeStrings = keyof typeof TenantType;
+    export enum TenantPermissionType {
+        read = 1,
+        write = 2,
+        notassigned = 3
+    }
+    type TenantPermissionTypeStrings = keyof typeof TenantPermissionType;
+    export class Tenant {
+        tid: string; // from AAD ID token
+        name: string; // findTenantInformationByTenantId
+        domain: string; // findTenantInformationByTenantId
+        tenantType: TenantTypeStrings; // always "aad" for now
+        permissionType: TenantPermissionTypeStrings; // read/write/notassigned
+        onboarded: string;  // have we onboarded this tenant? "true" or "false"
+        authority: string;  // from AAD ID auth response
+        readServicePrincipal: string; // from AAD consent
+        writeServicePrincipal: string; // from AAD consent
+        workspaceIDs: string;
+        constructor();
+    }
+    // config
+    export enum TenantConfigType {
+        source = 1,
+        target = 2,
+        sourcetarget = 3
+    }
+    export type TenantConfigTypeStrings = keyof typeof TenantConfigType;
+    export class TenantConfigInfo {
+        tid: string;              // tenant identifier
+        sourceGroupId: string;    // source group - we can configure source group for reading
+        sourceGroupName: string;  // source group - we can configure source group for reading
+        configurationTenantType: TenantConfigTypeStrings;
+        deltaToken: string;
+        filesWritten: number;
+        configId: string;
+    }
+    export class Config {
+        id: string;
+        workspaceId: string;
+        name: string;
+        description: string;
+        tenants: TenantConfigInfo[];
+        isEnabled: boolean;
+        workspaceIDs: string;
+        constructor();
+    }
+    // class to group Users, Tenants, and Configs
+    export class Workspace {
+        id: string;
+        name: string;
+        associatedUsers: string[];
+        associatedTenants: string[];
+        associatedConfigs: string[];
+        constructor();
+    }
+    export class InitInfo {
+        us: User[];
+        ts: Tenant[];
+        cs: Config[];
+        ws: Workspace[];
+        constructor(bClearLocalStorage: boolean);
+        init(bClearLocalStorage: boolean): void;
+        save(): void;
+        tagWithWorkspaces(): boolean;
+    }
+    export type TaskType = "initialization" | 
                             "authenticate user" | 
                             "reload React" | 
                             "PUT access token" | 
                             "GET tenant details" | 
                             "POST config init" |
                             "GET workspaces" |
-                          "onboard tenant" |
-                          "create 2nd tenant" |
-                          "invite 2nd admin" |
-                          "onboard 2nd tenant" | 
-                          "create config";
-  export class TaskArray {
-    tasks: Task[];  
-    constructor(bClearLocalStorage: boolean);
-    init(bClearLocalStorage: boolean): void;
-    setTaskStart(taskType: TaskType, startDate: Date): void;
-    setTaskEnd(taskType: TaskType, startDate: Date, status: string): void;
-  }
-  export class Task {
-    id: number;
-    task: string;
-    start: Date;
-    startDisplay: string;
-    end: Date;
-    endDisplay: string;
-    elapsedDisplay: string;
-    expected: number;
-    status: string;
-    expanded: boolean;
-    subtasks: Task[];
-    setEnd(endDate: Date): void;
-    setStart(startDate: Date): void;
-  }
-  export class BatchArray {
-    tenantNodes: TenantNode[];
-    constructor(config: Config|null, syncPortalGlobalState: InitInfo|null, bClearLocalStorage: boolean);
-    // populate tenantNodes based on config tenants
-    init(config: Config|null, syncPortalGlobalState: InitInfo|null, bClearLocalStorage: boolean): void;
-    startSync(instance: IPublicClientApplication, authorizedUser: User|null|undefined, config: Config|null|undefined): void;
-  }
-  export class TenantNode {
-    expanded: boolean;
-    status: string;
-    name: string;
-    tid: string;
-    total: number;
-    read: number;
-    written: number;
-    deferred: number;
-    targets: TenantNode[];
-    constructor(tid: string, name: string);
-    update(total: number, read: number, written: number, deferred: number): void;
-  }
-  export class APIResult {
-    result: boolean;
-    status: number;
-    error: string;
-    constructor();
-  }  
-  //
-  // Azure AD Graph API
-  //
-  export function groupGet(tenant: Tenant, groupid: string): Promise<{group: string, error: string}>;
-  export function groupsGet(tenant: Tenant, groupSearchString: string): Promise<{groups: Group[], error: string}>;
-  export function signIn(user: User, tasks: TaskArray): void;
-  export function signInIncrementally(user: User, scope: string): void;
-  export function signOut(user: User): void;
-  export function tenantRelationshipsGetByDomain(loggedInuser: User, tenant: Tenant, instance: IPublicClientApplication, debug: boolean): boolean;
-  export function tenantRelationshipsGetById(user: User, ii: InitInfo, instance: IPublicClientApplication, tasks: TaskArray, debug: boolean): boolean;
-  export function usersGet(tenant: Tenant): {users: string[], error: string};
-  //
-  // Mindline Config API
-  //
-  export function configEdit(instance: IPublicClientApplication, authorizedUser: User, config: Config, workspaceId: string, debug: boolean): APIResult;
-  export function configRemove(instance: IPublicClientApplication, authorizedUser: User, config: Config, workspaceId: string, debug: boolean): APIResult;
-  export function initGet(instance: IPublicClientApplication, authorizedUser: User, user: User, ii: InitInfo, tasks: TaskArray, debug: boolean): APIResult;
-  export function tenantAdd(instance: IPublicClientApplication, authorizedUser: User, tenant: Tenant, workspaceId: string): APIResult;
-  export function tenantComplete(instance: IPublicClientApplication, authorizedUser: User, tenant: Tenant, debug: boolean): APIResult;
-  export function tenantRemove(instance: IPublicClientApplication, authorizedUser: User, tenant: Tenant, workspaceId: string, debug: boolean): APIResult;
-  export function userAdd(instance: IPublicClientApplication, authorizedUser: User, user: User, workspaceId: string): APIResult;
+                            "onboard tenant" |
+                            "create 2nd tenant" |
+                            "invite 2nd admin" |
+                            "onboard 2nd tenant" | 
+                            "create config";
+    export class TaskArray {
+        tasks: Task[];  
+        constructor(bClearLocalStorage: boolean);
+        init(bClearLocalStorage: boolean): void;
+        setTaskStart(taskType: TaskType, startDate: Date): void;
+        setTaskEnd(taskType: TaskType, startDate: Date, status: string): void;
+    }
+    export class Task {
+        id: number;
+        task: string;
+        start: Date;
+        startDisplay: string;
+        end: Date;
+        endDisplay: string;
+        elapsedDisplay: string;
+        expected: number;
+        status: string;
+        expanded: boolean;
+        subtasks: Task[];
+        setEnd(endDate: Date): void;
+        setStart(startDate: Date): void;
+    }
+    export class BatchArray {
+        tenantNodes: TenantNode[];
+        constructor(config: Config|null, syncPortalGlobalState: InitInfo|null, bClearLocalStorage: boolean);
+        // populate tenantNodes based on config tenants
+        init(config: Config|null, syncPortalGlobalState: InitInfo|null, bClearLocalStorage: boolean): void;
+        startSync(instance: IPublicClientApplication, authorizedUser: User | null | undefined, config: Config | null | undefined, setConfigSyncResult: (syncUpdate: string) => void): APIResult;
+    }
+    export class TenantNode {
+        expanded: boolean;
+        status: string;
+        name: string;
+        tid: string;
+        batchId: string;
+        total: number;
+        read: number;
+        written: number;
+        deferred: number;
+        targets: TenantNode[];
+        constructor(tid: string, name: string);
+        update(total: number, read: number, written: number, deferred: number): void;
+    }
+    export class APIResult {
+        result: boolean;
+        status: number;
+        error: string;
+        constructor();
+    }  
+    //
+    // Azure AD Graph API
+    //
+    export function groupGet(tenant: Tenant, groupid: string): Promise<{group: string, error: string}>;
+    export function groupsGet(tenant: Tenant, groupSearchString: string): Promise<{groups: Group[], error: string}>;
+    export function signIn(user: User, tasks: TaskArray): void;
+    export function signInIncrementally(user: User, scope: string): void;
+    export function signOut(user: User): void;
+    export function tenantRelationshipsGetByDomain(loggedInuser: User, tenant: Tenant, instance: IPublicClientApplication, debug: boolean): boolean;
+    export function tenantRelationshipsGetById(user: User, ii: InitInfo, instance: IPublicClientApplication, tasks: TaskArray, debug: boolean): boolean;
+    export function tenantUnauthenticatedLookup(tenant: Tenant, debug: boolean): Promise<boolean>;
+    export function usersGet(tenant: Tenant): { users: string[], error: string };
+    //
+    // Mindline Config API
+    //
+    export function configEdit(instance: IPublicClientApplication, authorizedUser: User, config: Config, workspaceId: string, debug: boolean): APIResult;
+    export function configRemove(instance: IPublicClientApplication, authorizedUser: User, config: Config, workspaceId: string, debug: boolean): APIResult;
+    export function configsRefresh(instance: IPublicClientApplication, authorizedUser: User, workspaceId: string, ii: InitInfo, debug: boolean): APIResult;
+    export function initGet(instance: IPublicClientApplication, authorizedUser: User, user: User, ii: InitInfo, tasks: TaskArray, debug: boolean): APIResult;
+    export function tenantAdd(instance: IPublicClientApplication, authorizedUser: User, tenant: Tenant, workspaceId: string): APIResult;
+    export function tenantComplete(instance: IPublicClientApplication, authorizedUser: User, tenant: Tenant, debug: boolean): APIResult;
+    export function tenantRemove(instance: IPublicClientApplication, authorizedUser: User, tenant: Tenant, workspaceId: string, debug: boolean): APIResult;
+    export function userAdd(instance: IPublicClientApplication, authorizedUser: User, user: User, workspaceId: string): APIResult;
     export function userRemove(instance: IPublicClientApplication, authorizedUser: User, user: User, workspaceId: string): APIResult;
-  //
-  // Mindline Sync API
-  //
 }

package/index.ts

@@ -9,6 +9,7 @@ import tenants from "./tenants.json";
 import configs from "./configs.json";
 import workspaces from "./workspaces.json";
 import tasksData from "./tasks";
+import { log } from "console";
 const FILTER_FIELD = "workspaceIDs";
 // called by unit tests
 export function sum(a: number, b: number): number {
@@ -42,7 +43,7 @@ export class User {
         this.oid = "";
         this.name = "";
         this.mail = "";
-        this.authority = "https://login.microsoftonline.com/organizations/v2.0";
+        this.authority = "";
         this.tid = "";
         this.companyName = "";
         this.companyDomain = "";
@@ -87,12 +88,20 @@ export class Tenant {
         this.tenantType = "aad";
         this.permissionType = "notassigned";
         this.onboarded = "false";
-        this.authority = "https://login.microsoftonline.com/organizations/v2.0";
+        this.authority = "";
         this.readServicePrincipal = "";
         this.writeServicePrincipal = "";
         this.workspaceIDs = "";
     }
 }
+function getGraphEndpoint(authority: string): string {
+    switch (authority) {
+        case graphConfig.authorityWW: return "https://graph.microsoft.com/";
+        case graphConfig.authorityUS: return "https://graph.microsoft.us/";
+        case graphConfig.authorityCN: return "https://microsoftgraph.chinacloudapi.cn/";
+        default: debugger; return "";
+    }
+}
 export enum TenantConfigType {
     source = 1,
     target = 2,
@@ -106,6 +115,7 @@ export class TenantConfigInfo {
     configurationTenantType: TenantConfigTypeStrings;
     deltaToken: string;
     filesWritten: number;
+    configId: string;
     constructor() {
         this.tid = "";
         this.sourceGroupId = "";
@@ -113,6 +123,7 @@ export class TenantConfigInfo {
         this.configurationTenantType = "source";
         this.deltaToken = "";
         this.filesWritten = 0;
+        this.configId = "";
     }
 }
 export class Config {
@@ -531,134 +542,179 @@ export class BatchArray {
             }
         }
     }
-    /*
-    monitorSyncProgress(): void {
-        const connection = new signalR.HubConnectionBuilder()
-            .withUrl("https://dev-signalrdispatcher-westus.azurewebsites.net/?statsId=df9c2e0a-f6fe-43bb-a155-d51f66dffe0e")
-            .configureLogging(signalR.LogLevel.Information)
-            .build();
-
-        // when you get a message
-        connection.on("newMessage", function (message) {
-            console.log(message); // log the message
-            const item = JSON.parse(message); //parse it into an object
-            const statsarray = item.Stats; // get the array of statistics
-            const statskeys = Object.keys(statsarray); // get the keys of the array
-            const statsvalues = Object.values(statsarray); // get the values of the array
-            let statistics = ""; // initialize statistics
-            let total = 1;
-            let currentR = 0;
-            let currentW = 0;
-            let currentD = 0;
-            for (let j = 0; j < statskeys.length; j++) { 		// store the TotalCount and store as total
-                if (statskeys[j].endsWith("TotalCount")) {
-                    total = statsvalues[j];
-                }
-                if (statskeys[j].endsWith("CurrentCount")) { 	// store the Reader value as currentR
-                    if (statskeys[j].startsWith("Reader")) {
-                        currentR = statsvalues[j];
+    // start a sync cycle
+    async startSync(instance: IPublicClientApplication, authorizedUser: User | null | undefined, config: Config | null | undefined, setConfigSyncResult: (syncUpdate: string) => void): Promise<APIResult> {
+        let result: APIResult = new APIResult();
+        if (this.tenantNodes == null || this.tenantNodes.length == 0) {
+            // we should not have an empty batch array for a test
+            debugger;
+            result.result = false;
+            result.error = "startSync: invalid parameters";
+            result.status = 500;
+            return result;
+        }
+        // define newMessage handler that can access *this*
+        let handler = (message) => {
+            console.log(message);
+            let item = JSON.parse(message);
+            // find the associated tenant for this SignalR message
+            let tenantNode: TenantNode = this.tenantNodes.find((t: TenantNode) => t.tid === item.TargetID);
+            if (tenantNode == null) { // null OR undefined
+                console.log(`${item.TargetID} not found in BatchArray.`);
+                debugger;
+                return;
+            }
+            let writerNode: TenantNode|null = null;
+            // process stats for this SignalR message
+            let statsarray = item.Stats; // get the array of statistics
+            let statskeys = Object.keys(statsarray); // get the keys of the array
+            let statsvalues = Object.values(statsarray); // get the values of the array
+            for (let j = 0; j < statskeys.length; j++) {
+                if (statskeys[j].startsWith("Reader")) {
+                    if (statskeys[j].endsWith("TotalCount")) {
+                        // parse batchId from key and store in TenantNode for this batch
+                        let batchidRegexp = /Reader\/BID:(.+)\/TotalCount/;
+                        let matchBID = statskeys[j].match(batchidRegexp);
+                        if (matchBID == null) {
+                            console.log(`batchId not found in ${statskeys[j]}.`);
+                            debugger;
+                            return;
+                        }
+                        // integrate any queued Writers that have been waiting for this batchId to be assigned to a Reader
+                        let idx: number = this.tenantNodes.findIndex((t: TenantNode) => (t.name === "QUEUED WRITER" && t.batchId === matchBID[1]));
+                        while (idx !== -1) {
+                            let queuedWriter: TenantNode = this.tenantNodes.splice(idx, 1)[0];
+                            let actualWriter: TenantNode = tenantNode.targets.find((t: TenantNode) => t.tid == queuedWriter.tid);
+                            if (actualWriter == null) {
+                                console.log(`could not find queued writer ${queuedWriter.tid}.`);
+                                debugger;
+                            }
+                            else {
+                                actualWriter.update(queuedWriter.total, queuedWriter.read, queuedWriter.written, queuedWriter.deferred);
+                            }
+                            idx = this.tenantNodes.findIndex((t: TenantNode) => (t.name === "QUEUED WRITER" && t.batchId === matchBID[1]));
+                        }
+                        // update Read node
+                        tenantNode.batchId = matchBID[1];
+                        tenantNode.total = Number(statsvalues[j]);
+                        console.log(`----- ${tenantNode.name} batchId: ${tenantNode.batchId}`);
+                        console.log(`----- ${tenantNode.name} Total Read: ${tenantNode.total}`);
                     }
-                    if (statskeys[j].startsWith("Writer")) { 		// store the Writer value as currentW
-                        currentW = statsvalues[j];
+                    if (statskeys[j].endsWith("CurrentCount")) {
+                        tenantNode.read = Number(statsvalues[j]);
+                        console.log(`----- ${tenantNode.name} Currently Read: ${tenantNode.read}`);
                     }
                 }
-                if (statskeys[j].endsWith("DeferredCount")) { 		// store the deferred count
-                    currentD = statsvalues[j];
+                if (statskeys[j].startsWith("Writer")) {
+                    if (statskeys[j].endsWith("TotalCount")) {
+                        // parse batchId from Writer key
+                        let batchidRegexp = /Writer\/BID:(.+)\/TotalCount/;
+                        let matchBID = statskeys[j].match(batchidRegexp);
+                        if (matchBID == null) {
+                            console.log(`batchId not found in ${statskeys[j]}.`);
+                            debugger;
+                            return;
+                        }
+                        // find the Writer node for this tenant under the Reader node of a different tenant
+                        let readerNode: TenantNode = this.tenantNodes.find((t: TenantNode) => t.batchId === matchBID[1]);
+                        if (readerNode == null) {
+                            // reader for this batch has not yet been encountered, queue this writer for processing when reader arrives
+                            writerNode = new TenantNode(tenantNode.tid, "QUEUED WRITER");
+                            writerNode.batchId = matchBID[1];
+                            writerNode.total = Number(statsvalues[j]);
+                            this.tenantNodes.push(writerNode);
+                            console.log(`----- QUEUED batchId: ${writerNode.batchId}`);
+                            console.log(`----- QUEUED Total To Write: ${writerNode.total}`);
+                        }
+                        else {
+                            if (readerNode.name == "QUEUED WRITER") {
+                                // update queued node
+                                writerNode = readerNode;
+                            }
+                            else {
+                                // reader is legit, find writer node under this reader node
+                                writerNode = readerNode.targets.find((t: TenantNode) => t.tid === tenantNode.tid);
+                                if (writerNode == null) {
+                                    console.log(`Writer ${tenantNode.name} not found under Reader ${readerNode.name}.`);
+                                    debugger;
+                                    return;
+                                }
+                            }
+                            writerNode.batchId = matchBID[1];
+                            writerNode.total = Number(statsvalues[j]);
+                            console.log(`----- ${writerNode.name} batchId: ${writerNode.batchId}`);
+                            console.log(`----- ${writerNode.name} Total To Write: ${writerNode.total}`);
+                        }
+                    }
+                    if (statskeys[j].endsWith("CurrentCount")) {
+                        // parse batchId from Writer key
+                        let batchidRegexp = /Writer\/BID:(.+)\/CurrentCount/;
+                        let matchBID = statskeys[j].match(batchidRegexp);
+                        if (matchBID == null) {
+                            console.log(`batchId not found in ${statskeys[j]}.`);
+                            debugger;
+                            return;
+                        }
+                        // find the Writer node for this tenant under the Reader node of a different tenant
+                        let readerNode: TenantNode = this.tenantNodes.find((t: TenantNode) => t.batchId === matchBID[1]);
+                        if (readerNode == null) {
+                            // no reader or queued writer for this batch
+                            console.log(`No reader or queued writer for batch ${matchBID[1]}.`);
+                            debugger;
+                            return;
+                        }
+                        if (readerNode.name == "QUEUED WRITER") {
+                            // update queued node
+                            writerNode = readerNode;
+                        }
+                        else {
+                            // reader is legit, find writer node under this reader node
+                            writerNode = readerNode.targets.find((t: TenantNode) => t.tid === tenantNode.tid);
+                            if (writerNode == null) {
+                                console.log(`Writer ${tenantNode.name} not found under Reader ${readerNode.name}.`);
+                                debugger;
+                                return;
+                            }
+                        }
+                        writerNode.batchId = matchBID[1];
+                        writerNode.written = Number(statsvalues[j]);
+                        console.log(`${writerNode.name} batchId: ${writerNode.batchId}`);
+                        console.log(`${writerNode.name} Total Written: ${writerNode.written}`);
+                    }
                 }
-                statistics = statistics + statskeys[j] + "=" + statsvalues[j] + "<br />" 	// 
-            }
-            updateProgress(total, currentR, currentW, currentD);
-            myFunction(item.TargetID, statistics);
-        });
-
-        connection.start().catch(console.error);
-
-        function myFunction(targetid, str) {
-            const table = document.getElementById("the-table");
-            let row = document.getElementById(targetid);
-            if (row) {
-                row.cells[1].innerHTML = "<code>" + str + "</ code>";
-            } else {
-                row = table.insertRow(1);
-                row.id = targetid;
-                let cell1 = row.insertCell(0);
-                let cell2 = row.insertCell(1);
-                let caption = (targetid === "00000000-0000-0000-0000-000000000000") ? "<B>Status of ServiceBus QUEUES</B>" : targetid;
-                cell1.innerHTML = "<code>" + caption + "</ code>";
-                cell2.innerHTML = "<code>" + str + "</ code>";
             }
-        }
-
-        function updateProgress(total, currentR, currentW, currentD) {
-            updateRead(total, currentR);
-            updateWrite(total, currentW, currentD);
-        }
-
-        function updateRead(total, current) {
-            const element = document.getElementById("readBar");
-            const width = Math.round(100 * current / total);
-            element.style.width = width + '%';
-            element.innerHTML = "R=" + width + '%';
-        }
-
-        function updateWrite(total, w, d) {
-            const elementW = document.getElementById("writeBar");
-            const widthW = Math.round(100 * w / total);
-            elementW.style.width = widthW + '%';
-            elementW.innerHTML = "W=" + widthW + '%';
-
-            const elementD = document.getElementById("deferBar");
-            let width = 0;
-            let widthScaled = 0;
-            if (d > 0) {
-                width = Math.round(100 * d / total) + 1;
-                if (width < 10) {
-                    widthScaled = width * 10;
-                }
-                else if (width < 20) {
-                    widthScaled = width * 5;
+            tenantNode.update(tenantNode.total, tenantNode.read, tenantNode.written, tenantNode.deferred);
+            if (writerNode != null) {
+                writerNode.update(writerNode.total, writerNode.read, writerNode.written, writerNode.deferred);
+                if (tenantNode.total === tenantNode.read && writerNode.total === writerNode.written) {
+                    setConfigSyncResult("complete");
+                    console.log(`Setting config sync result: "complete"`);
                 }
                 else {
-                    widthScaled = width;
+                    setConfigSyncResult("writing in progress");
+                    console.log(`Setting config sync result: "writing in progress"`);
                 }
             }
-            if (widthScaled + widthW >= 99) {
-                widthScaled = 99 - widthW;
-            }
-            elementD.style.width = widthScaled + '%';
-            elementD.innerHTML = width + '%';
-            document.getElementById("deferred").innerHTML = 'Deferred:' + width + '% (' + d + ' of ' + total + ')';
-            // cycle through desired states for sources and targets
-            if (this.tenantNodes != null) {
-                this.tenantNodes.map((sourceTenantNode: TenantNode) => {
-                    if (sourceTenantNode.read == 0) sourceTenantNode.update(100, 50, 0, 0);
-                    else if (sourceTenantNode.read == 50) sourceTenantNode.update(100, 100, 0, 0);
-                    else sourceTenantNode.update(0, 0, 0, 0);
-                    if (sourceTenantNode.targets != null) {
-                        sourceTenantNode.targets.map((targetTenantNode: TenantNode) => {
-                            if (targetTenantNode.written == 0) targetTenantNode.update(100, 0, 50, 0);
-                            else if (targetTenantNode.written == 50) targetTenantNode.update(100, 0, 100, 0);
-                            else if (targetTenantNode.written == 100) targetTenantNode.update(100, 0, 99, 1);
-                            else targetTenantNode.update(0, 0, 0, 0);
-                        });
-                    }
-                });
+            else {
+                setConfigSyncResult("reading in progress");
+                console.log(`Setting config sync result: "reading in progress"`);
             }
         }
-    }
-    */
-    // cycle through test state machine
-    startSync(instance: IPublicClientApplication, authorizedUser: User | null | undefined, config: Config | null | undefined): void {
-        if (this.tenantNodes == null || this.tenantNodes.length == 0) {
-            // we should not have an empty batch array for a test
-            debugger;
-        }
+        // start SignalR connection for each source tenant in the configuration
+        this.tenantNodes.map((sourceTenantNode: TenantNode) => {
+            const endpointUrl = `https://dev-signalrdispatcher-westus.azurewebsites.net/statsHub?statsId=${sourceTenantNode.tid}`;
+            const connection: signalR.HubConnection = new signalR.HubConnectionBuilder()
+                .withUrl(endpointUrl)
+                // .withAutomaticReconnect() TODO: full auto-reconnect implementation
+                .configureLogging(signalR.LogLevel.Information)
+                .build();
+            // when you get a message, process the message
+            connection.on("newMessage", handler);
+            connection.start().catch(console.error);
+        });
         // execute post to reader endpoint
-        readerPost(instance, authorizedUser, config);
-
-        // start SignalR connection
-        //debugger;
-        //monitorSyncProgress();
+        result = await readerPost(instance, authorizedUser, config);
+        return result;
     }
 }
 export class TenantNode {
@@ -666,6 +722,7 @@ export class TenantNode {
     status: string;
     name: string;
     tid: string;
+    batchId: string;
     total: number;
     read: number;
     written: number;
@@ -675,6 +732,7 @@ export class TenantNode {
         this.expanded = false;
         this.name = name;
         this.tid = tid;
+        this.batchId = "";
         this.targets = new Array<TenantNode>();
         this.update(0, 0, 0, 0);
     }
@@ -806,9 +864,9 @@ export function signOut(user: User): void {
 export async function tenantRelationshipsGetByDomain(loggedInUser: User, tenant: Tenant, instance: IPublicClientApplication, debug: boolean): Promise<boolean> {
     if (debug) debugger;
     // do we already have a valid tenant name? if so, nothing to add
-    if (typeof tenant.name !== 'undefined' && tenant.name !== "") return false;
+    if (tenant.name != null && tenant.name !== "") return false;
     // if needed, retrieve and cache access token
-    if (typeof loggedInUser.accessToken === 'undefined' || loggedInUser.accessToken === "") {
+    if (loggedInUser.accessToken != null && loggedInUser.accessToken === "") {
         console.log(`tenantRelationshipsGetByDomain called with invalid logged in user: ${loggedInUser.name}`);
         try {
             let response: AuthenticationResult = await instance.acquireTokenByCode({ code: loggedInUser.spacode });
@@ -828,29 +886,32 @@ export async function tenantRelationshipsGetByDomain(loggedInUser: User, tenant:
     // make tenant endpoint call
     try {
         // create tenant info endpoint
-        var tenantEndpoint = graphConfig.graphTenantByDomainEndpoint;
+        var tenantEndpoint = getGraphEndpoint(tenant.authority) + graphConfig.graphTenantByDomainPredicate;
         tenantEndpoint += "(domainName='";
         tenantEndpoint += tenant.domain;
         tenantEndpoint += "')";
         console.log("Attempting GET from /findTenantInformationByDomainName:", tenantEndpoint);
         let response = await fetch(tenantEndpoint, options);
-        let data = await response.json();
-        if (data) {
-            if (typeof data.error !== "undefined") {
-                console.log("Failed GET from /findTenantInformationByDomainName: ", data.error.message);
-                return false;
+        if (response.status == 200 && response.statusText == "OK") {
+            let data = await response.json();
+            if (data) {
+                if (data.error != null) {
+                    debugger;
+                    console.log("Failed GET from /findTenantInformationByDomainName: ", data.error.message);
+                    return false;
+                }
+                else if (data.displayName != null && data.displayName !== "") {
+                    // set domain information on passed tenant
+                    tenant.tid = data.tenantId;
+                    tenant.name = data.displayName;
+                    console.log("Successful GET from /findTenantInformationByDomainName: ", data.displayName);
+                    return true;  // success, need UX to re-render
+                }
             }
-            else if (typeof data.displayName !== undefined && data.displayName !== "") {
-                // set domain information on passed tenant
-                tenant.tid = data.tenantId;
-                tenant.name = data.displayName;
-                console.log("Successful GET from /findTenantInformationByDomainName: ", data.displayName);
-                return true;  // success, need UX to re-render
+            else {
+                console.log("Failed to GET from /findTenantInformationByTenantId: ", tenantEndpoint);
             }
         }
-        else {
-            console.log("Failed to GET from /findTenantInformationByTenantId: ", tenantEndpoint);
-        }
     }
     catch (error: any) {
         console.log("Failed to GET from /findTenantInformationByTenantId: ", error);
@@ -862,9 +923,9 @@ export async function tenantRelationshipsGetByDomain(loggedInUser: User, tenant:
 export async function tenantRelationshipsGetById(user: User, ii: InitInfo, instance: IPublicClientApplication, tasks: TaskArray, debug: boolean): Promise<boolean> {
     if (debug) debugger;
     // do we already have a valid company name? if so, nothing to add, no need for UX to re-render
-    if (typeof user.companyName !== 'undefined' && user.companyName !== "") return false;
+    if (user.companyName != "") return false;
     // if needed, retrieve and cache access token
-    if (typeof user.accessToken === 'undefined' || user.accessToken === "") {
+    if (user.accessToken === "") {
         try {
             let response: AuthenticationResult = await instance.acquireTokenByCode({ code: user.spacode });
             user.accessToken = response.accessToken; // cache access token
@@ -883,7 +944,7 @@ export async function tenantRelationshipsGetById(user: User, ii: InitInfo, insta
     // make tenant endpoint call
     try {
         // create tenant info endpoint
-        var tenantEndpoint = graphConfig.graphTenantByIdEndpoint;
+        var tenantEndpoint = getGraphEndpoint(user.authority) + graphConfig.graphTenantByIdPredicate;
         tenantEndpoint += "(tenantId='";
         tenantEndpoint += user.tid;
         tenantEndpoint += "')";
@@ -922,6 +983,54 @@ export async function tenantRelationshipsGetById(user: User, ii: InitInfo, insta
     tasks.setTaskEnd("GET tenant details", new Date(), "failed");
     return false; // failed, no need for UX to re-render
 }
+//tenantUnauthenticatedLookup (from https://gettenantpartitionweb.azurewebsites.net/js/gettenantpartition.js)
+export async function tenantUnauthenticatedLookup(tenant: Tenant, debug: boolean): Promise<boolean> {
+    if (debug) debugger;
+    // do we already have a valid tenant ID? if so, nothing to add
+    if (tenant.tid !== "") return false;
+    // do we not have a valid domain? if so, nothing to lookup
+    if (tenant.domain == "") return false;
+    // prepare the 3 endpoints and corresponding regular expressions
+    let endpoints: string[] = [graphConfig.authorityWW, graphConfig.authorityUS, graphConfig.authorityCN];
+    let regexes: RegExp[] = [graphConfig.authorityWWRegex, graphConfig.authorityUSRegex, graphConfig.authorityCNRegex];
+    // make unauthenticated well-known openid endpoint call(s)
+    let response = null;
+    try {
+        for (let j = 0; j < 3; j++) {
+            // create well-known openid endpoint
+            var openidEndpoint = endpoints[j];
+            openidEndpoint += tenant.domain;
+            openidEndpoint += "/.well-known/openid-configuration";
+            console.log("Attempting GET from openid well-known endpoint: ", openidEndpoint);
+            response = await fetch(openidEndpoint);
+            if (response.status == 200 && response.statusText == "OK") {
+                let data = await response.json();
+                if (data) {
+                    // store tenant ID and authority
+                    var tenantAuthEndpoint = data.authorization_endpoint;
+                    var authMatches = tenantAuthEndpoint.match(regexes[j]);
+                    tenant.tid = authMatches[2];
+                    tenant.authority = authMatches[1];  // USGov tenants are registered in WW with USGov authority values!
+                    console.log("Successful GET from openid well-known endpoint");
+                    return true;  // success, need UX to re-render
+                }
+                else {
+                    console.log(`Failed JSON parse of openid well-known endpoint response ${openidEndpoint}.`);
+                }
+            }
+            else {
+                console.log(`Failed GET from ${openidEndpoint}.`);
+            }
+        }
+    }
+    catch (error: any) {
+        console.log("Failed to GET from openid well-known endpoint: ", error);
+    }
+    if (tenant.tid == "" || tenant.authority == "") {
+        console.log(`GET from openid well-known endpoint failed to find tenant: ${response ? response.statusText : "unknown"}`);
+    }
+    return false; // failed, no need for UX to re-render
+}
 //usersGet - GET from AAD Users endpoint
 export async function usersGet(tenant: Tenant): Promise<{ users: string[], error: string }> {
     // need a read or write access token to get graph users
@@ -970,26 +1079,77 @@ export async function configEdit(instance: IPublicClientApplication, authorizedU
 export async function configRemove(instance: IPublicClientApplication, authorizedUser: User, config: Config, workspaceId: string, debug: boolean): Promise<APIResult> {
     return configDelete(instance, authorizedUser, config, workspaceId, debug);
 }
+export async function configsRefresh(instance: IPublicClientApplication, authorizedUser: User, workspaceId: string, ii: InitInfo, debug: boolean): Promise<APIResult> {
+    let result: APIResult = new APIResult();
+    if (debug) debugger;
+    try {
+        let workspace: Workspace = ii.ws.find((w) => w.id === workspaceId);
+        if (workspace != null) {
+            // clear Config associations as we are about to reset
+            workspace.associatedConfigs.length = 0;
+            // GET configs associated with this workspace
+            let configsPromise: Promise<APIResult> = configsGet(instance, authorizedUser, workspace.id, debug);
+            // wait for query to finish, return on any failure
+            let [configsResult] = await Promise.all([configsPromise]);
+            if (!configsResult.result) return configsResult;
+            // process returned workspace components
+            processReturnedConfigs(workspace, ii, configsResult.array!);
+            // tag components with workspaceIDs
+            ii.tagWithWorkspaces();
+        }
+        return result;
+    }
+    catch (error: any) {
+        console.log(error.message);
+        result.error = error.message;
+    }
+    result.result = false;
+    result.status = 500;
+    return result;
+}
 // retrieve Workspace(s), User(s), Tenant(s), Config(s) given newly logged in user
 export async function initGet(instance: IPublicClientApplication, authorizedUser: User, user: User, ii: InitInfo, tasks: TaskArray, debug: boolean): Promise<APIResult> {
     let result: APIResult = new APIResult();
     if (debug) debugger;
-    // get tenant name and domain from AAD
-    result.result = await tenantRelationshipsGetById(user, ii, instance, tasks, debug);
-    // if this is the first time, we have just gotten tenant info, then we must POST user and not-yet-onboarded tenant to back end
-    if (result.result) {
-        tasks.setTaskStart("POST config init", new Date());
-        result = await initPost(instance, authorizedUser, user, debug);
-        tasks.setTaskEnd("POST config init", new Date(), result.result ? "complete" : "failed");
+    // lookup authority for this user (the lookup call does it based on domain, but TID works as well to find authority)
+    let tenant: Tenant = new Tenant();
+    tenant.domain = user.tid;
+    let bResult: boolean = await tenantUnauthenticatedLookup(tenant, debug);
+    if (bResult) {
+        // success, we at least got authority as a new bit of information at this point
+        user.authority = tenant.authority;
+        // do we have a logged in user from the same authority as this newly proposed tenant?
+        let loggedInUser: User | undefined = ii.us.find((u: User) => (u.session === "Sign Out" && u.authority === user.authority));
+        if (loggedInUser != null) {
+            // get tenant name and domain from AAD
+            result.result = await tenantRelationshipsGetById(user, ii, instance, tasks, debug);
+            // if this is the first time, we have just gotten tenant info, then we must POST user and not-yet-onboarded tenant to back end
+            if (result.result) {
+                tasks.setTaskStart("POST config init", new Date());
+                result = await initPost(instance, authorizedUser, user, debug);
+                tasks.setTaskEnd("POST config init", new Date(), result.result ? "complete" : "failed");
+            }
+            // simlarly, if we just did our first post, then query config backend for workspace(s) associated with this user
+            if (result.result) {
+                tasks.setTaskStart("GET workspaces", new Date());
+                result = await workspaceInfoGet(instance, authorizedUser, user, ii, debug);
+                tasks.setTaskEnd("GET workspaces", new Date(), result.result ? "complete" : "failed");
+            }
+            if (result.result) result.error = version;
+            else console.log("@mindline/sync package version: " + version);
+            return result;
+        }
+        else {
+            result.error = `${user.mail} insufficient privileges to lookup under authority: ${user.authority}.`;
+            result.result = false;
+            return result;
+        }
     }
-    // simlarly, if we just did our first post, then query config backend for workspace(s) associated with this user
-    if (result.result) {
-        tasks.setTaskStart("GET workspaces", new Date());
-        result = await workspaceInfoGet(instance, authorizedUser, user, ii, debug);
-        tasks.setTaskEnd("GET workspaces", new Date(), result.result ? "complete" : "failed");
+    else {
+        result.error = `Failed to retrieve authority for user "${user.mail}" TID ${user.tid}.`;
+        result.result = false;
+        return result;
     }
-    if (result.result) result.error = version;
-    return result;
 }
 export async function tenantAdd(instance: IPublicClientApplication, authorizedUser: User, tenant: Tenant, workspaceId: string): Promise<APIResult> {
     return tenantPost(instance, authorizedUser, tenant, workspaceId);
@@ -1053,7 +1213,7 @@ function processReturnedTenants(workspace: Workspace, ii: InitInfo, returnedTena
                 // clear and overwrite dummy
                 tenant = ii.ts.at(dummyIndex);
             } else {
-                // create and track new workspace
+                // create and track new tenant
                 tenant = new Tenant();
                 ii.ts.push(tenant);
             }
@@ -1109,6 +1269,7 @@ function processReturnedConfigs(workspace: Workspace, ii: InitInfo, returnedConf
             tenantConfigInfo.sourceGroupName = tci.sourceGroupName;
             tenantConfigInfo.configurationTenantType = tci.configurationTenantType.toLowerCase();
             tenantConfigInfo.deltaToken = tci.deltaToken ?? "";
+            tenantConfigInfo.configId = config!.id;
             config!.tenants.push(tenantConfigInfo);
         });
         // ensure this workspace tracks this config

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mindline/sync",
   "type": "module",
-  "version": "1.0.35",
+  "version": "1.0.37",
   "types": "index.d.ts",
   "exports": "./index.ts",
   "description": "sync is a node.js package encapsulating javscript classes required for configuring Mindline sync service.",
@@ -13,9 +13,13 @@
   "author": "",
   "license": "ISC",
   "devDependencies": {
+    "@types/react": "^18.2.21",
+    "@types/react-dom": "^18.2.7",
+    "typescript": "^5.2.2",
     "vitest": "^0.29.8"
   },
   "dependencies": {
+    "@microsoft/signalr": "^7.0.10",
     "class-transformer": "^0.5.1",
     "reflect-metadata": "^0.1.13"
   }

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "lib": [ "DOM", "DOM.Iterable", "ESNext" ],
+    "types": [ "vite/client", "vite-plugin-svgr/client", "node", "jest" ],
+    "allowJs": false,
+    "skipLibCheck": false,
+    "esModuleInterop": false,
+    "allowSyntheticDefaultImports": true,
+    "forceConsistentCasingInFileNames": true,
+    "module": "esnext",
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "composite": false,
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["src"],
+  "references": [{ "path": "./tsconfig.node.json" }]
+}

package/tsconfig.node.json

@@ -0,0 +1,9 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "skipLibCheck": true,
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "allowSyntheticDefaultImports": true
+  }
+}