Adds support for REST endpoint to get objects (#34)

* feat: Working REST endpoint to fetch objects instead of GraphQL

* hack: Temporarily exposed rest function

* feat: Added OAuth test login

* chore: Cleanup for release

.circleci/config.yml

@@ -0,0 +1,58 @@
+# Use the latest 2.1 version of CircleCI pipeline process engine.
+# See: https://circleci.com/docs/2.0/configuration-reference
+version: 2.1
+
+orbs:
+  win: circleci/windows@5.0
+
+jobs:
+  build-connector:
+    executor:
+      name: win/default
+      shell: powershell.exe
+    steps:
+      - checkout
+      - run:
+          name: "Set connector internal version"
+          command: |
+            $VERSION = if([string]::IsNullOrEmpty($env:CIRCLE_TAG)) { "2.0.0.$($env:WORKFLOW_NUM)" } else { $env:CIRCLE_TAG }
+            (Get-Content ./Speckle.pq).replace('[Version = "2.0.0"]', '[Version = "'+$($env:VERSION)+'"]') | Set-Content ./Speckle.pq
+      - run:
+          name: "Build Data Connector"
+          command: "msbuild Speckle.proj /restore /consoleloggerparameters:NoSummary /property:GenerateFullPaths=true"
+      - store_artifacts:
+          path: ./bin
+      - persist_to_workspace:
+          root: ./
+          paths:
+            - bin/*
+  deploy-connector:
+    docker:
+      - image: cibuilds/github:0.10
+    steps:
+      - attach_workspace:
+          at: ./
+      - run:
+          name: "Publish Release on GitHub"
+          command: |
+            ghr -t ${GITHUB_TOKEN} -u ${CIRCLE_PROJECT_USERNAME} -r ${CIRCLE_PROJECT_REPONAME} -c ${CIRCLE_SHA1} ${CIRCLE_TAG} ./bin/
+workflows:
+  build:
+    jobs:
+      - build-connector
+  deploy:
+    jobs:
+      - build-connector:
+          filters:
+            branches:
+              ignore: /.*/ # For testing only: /ci\/.*/
+            tags:
+              only: /^([0-9]+)\.([0-9]+)\.([0-9]+)(?:-\w{1,10})?$/
+      - deploy-connector:
+          filters:
+            branches:
+              ignore: /.*/ # For testing only: /ci\/.*/
+            tags:
+              only: /^([0-9]+)\.([0-9]+)\.([0-9]+)(?:-\w{1,10})?$/
+          requires:
+            - build-connector

.github/workflows/close-issue.yml

@@ -0,0 +1,77 @@
+name: Update issue Status
+
+on:
+  issues:
+    types: [closed]
+
+jobs:
+  update_issue:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Get project data
+        env:
+          GITHUB_TOKEN: ${{secrets.GHPROJECT_TOKEN}}
+          ORGANIZATION: specklesystems
+          PROJECT_NUMBER: 11
+        run: |
+          gh api graphql --header 'GraphQL-Features: projects_next_graphql' -f query='
+            query($org: String!, $number: Int!) {
+              organization(login: $org){
+                projectNext(number: $number) {
+                  id
+                  fields(first:20) {
+                    nodes {
+                      id
+                      name
+                      settings
+                    }
+                  }
+                }
+              }
+            }' -f org=$ORGANIZATION -F number=$PROJECT_NUMBER > project_data.json
+
+          echo 'PROJECT_ID='$(jq '.data.organization.projectNext.id' project_data.json) >> $GITHUB_ENV
+          echo 'STATUS_FIELD_ID='$(jq '.data.organization.projectNext.fields.nodes[] | select(.name== "Status") | .id' project_data.json) >> $GITHUB_ENV
+
+          echo "$PROJECT_ID"
+          echo "$STATUS_FIELD_ID"
+
+          echo 'DONE_ID='$(jq '.data.organization.projectNext.fields.nodes[] | select(.name== "Status") | .settings | fromjson | .options[] | select(.name== "Done") | .id' project_data.json) >> $GITHUB_ENV
+          echo "$DONE_ID"
+
+      - name: Add Issue to project #it's already in the project, but we do this to get its node id!
+        env:
+          GITHUB_TOKEN: ${{secrets.GHPROJECT_TOKEN}}
+          ISSUE_ID: ${{ github.event.issue.node_id }}
+        run: |
+          item_id="$( gh api graphql --header 'GraphQL-Features: projects_next_graphql' -f query='
+            mutation($project:ID!, $id:ID!) {
+              addProjectNextItem(input: {projectId: $project, contentId: $id}) {
+                projectNextItem {
+                  id
+                }
+              }
+            }' -f project=$PROJECT_ID -f id=$ISSUE_ID --jq '.data.addProjectNextItem.projectNextItem.id')"
+
+          echo 'ITEM_ID='$item_id >> $GITHUB_ENV
+
+      - name: Update Status
+        env:
+          GITHUB_TOKEN: ${{secrets.GHPROJECT_TOKEN}}
+          ISSUE_ID: ${{ github.event.issue.node_id }}
+        run: |
+          gh api graphql --header 'GraphQL-Features: projects_next_graphql' -f query='
+            mutation($project:ID!, $status:ID!, $id:ID!, $value:String!) {
+              set_status: updateProjectNextItemField(
+                input: {
+                  projectId: $project
+                  itemId: $id
+                  fieldId: $status
+                  value: $value
+                }
+              ) {
+                projectNextItem {
+                  id
+                }
+              }
+            }' -f project=$PROJECT_ID -f status=$STATUS_FIELD_ID -f id=$ITEM_ID -f value=${{ env.DONE_ID }}

.github/workflows/open-issue.yml

@@ -0,0 +1,50 @@
+name: Move new issues into Project
+
+on:
+  issues:
+    types: [opened]
+
+jobs:
+  track_issue:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Get project data
+        env:
+          GITHUB_TOKEN: ${{secrets.GHPROJECT_TOKEN}}
+          ORGANIZATION: specklesystems
+          PROJECT_NUMBER: 11
+        run: |
+          gh api graphql --header 'GraphQL-Features: projects_next_graphql' -f query='
+            query($org: String!, $number: Int!) {
+              organization(login: $org){
+                projectNext(number: $number) {
+                  id
+                  fields(first:20) {
+                    nodes {
+                      id
+                      name
+                      settings
+                    }
+                  }
+                }
+              }
+            }' -f org=$ORGANIZATION -F number=$PROJECT_NUMBER > project_data.json
+
+          echo 'PROJECT_ID='$(jq '.data.organization.projectNext.id' project_data.json) >> $GITHUB_ENV
+          echo 'STATUS_FIELD_ID='$(jq '.data.organization.projectNext.fields.nodes[] | select(.name== "Status") | .id' project_data.json) >> $GITHUB_ENV
+
+      - name: Add Issue to project
+        env:
+          GITHUB_TOKEN: ${{secrets.GHPROJECT_TOKEN}}
+          ISSUE_ID: ${{ github.event.issue.node_id }}
+        run: |
+          item_id="$( gh api graphql --header 'GraphQL-Features: projects_next_graphql' -f query='
+            mutation($project:ID!, $id:ID!) {
+              addProjectNextItem(input: {projectId: $project, contentId: $id}) {
+                projectNextItem {
+                  id
+                }
+              }
+            }' -f project=$PROJECT_ID -f id=$ISSUE_ID --jq '.data.addProjectNextItem.projectNextItem.id')"
+
+          echo 'ITEM_ID='$item_id >> $GITHUB_ENV

.vscode/launch.json

@@ -0,0 +1,12 @@
+{
+  "configurations": [
+    {
+      "type": "powerquery",
+      "request": "launch",
+      "name": "Test powerquery file",
+      "program": "${workspaceFolder}/${command:AskForPowerQueryFileName}",
+      "additionalArgs": ["--logMashupEngineTraces", "user"],
+      "preLaunchTask": "build"
+    }
+  ]
+}

.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+  "powerquery.general.mode": "SDK",
+  "powerquery.sdk.defaultExtension": "${workspaceFolder}\\bin\\Speckle.mez",
+  "powerquery.sdk.defaultQueryFile": "${workspaceFolder}\\Speckle.query.pq"
+}

.vscode/tasks.json

@@ -0,0 +1,31 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "type": "powerquery",
+      "operation": "msbuild",
+      "additionalArgs": [
+        "/restore",
+        "/consoleloggerparameters:NoSummary",
+        "/property:GenerateFullPaths=true"
+      ],
+      "problemMatcher": ["$msCompile"],
+      "group": "build",
+      "label": "build"
+    },
+    {
+      "type": "shell",
+      "label": "tests",
+      "command": "${config:powerquery.sdk.tools.location}\\PQTest.exe",
+      "args": [
+        "run-test",
+        "--extension",
+        "${config:powerquery.sdk.defaultExtension}",
+        "--queryFile",
+        "${workspaceFolder}\\tests",
+        "--prettyPrint"
+      ],
+      "problemMatcher": []
+    }
+  ]
+}

Speckle.pq

@@ -0,0 +1,201 @@
+[Version = "2.0.0"]
+section Speckle;
+
+// The data source definition, used when connecting to any speckle server
+Speckle = [
+    // This is used when running the connector on an on-premises data gateway
+    TestConnection = (path) => {"Speckle.Api.GetUser", path},
+    // This is the custom authentication strategy for our Connector
+    Authentication = [
+        OAuth = [
+            Label = "Speckle Login (latest only)",
+            StartLogin = (clientApplication, dataSourcePath, state, display) =>
+                [
+                    LoginUri = Text.Combine({"https://latest.speckle.dev/authn/verify", "1ea917e25a", state}, "/"),
+                    CallbackUri = "https://oauth.powerbi.com/views/oauthredirect.html",
+                    WindowHeight = 800,
+                    WindowWidth = 600,
+                    Context = null
+                ],
+            FinishLogin = (clientApplication, dataSourcePath, context, callbackUri, state) =>
+                let
+                    Parts = Uri.Parts(callbackUri)[Query],
+                    Source = Web.Contents(
+                        Text.Combine({"https://latest.speckle.dev", "auth", "token"}, "/"),
+                        [
+                            Headers = [
+                                #"Content-Type" = "application/json"
+                            ],
+                            Content = Json.FromValue(
+                                [
+                                    accessCode = Parts[access_code],
+                                    appId = "1ea917e25a",
+                                    appSecret = "7d1cb26028",
+                                    challenge = state
+                                ]
+                            )
+                        ]
+                    ),
+                    json = Json.Document(Source)
+                in
+                    [
+                        access_token = json[token],
+                        scope = null,
+                        token_type = "bearer",
+                        refresh_token = json[refreshToken]
+                    ],
+            Refresh = (dataSourcePath, refreshToken) =>
+                let
+                    Source = Web.Contents(
+                        Text.Combine({"https://latest.speckle.dev", "auth", "token"}, "/"),
+                        [
+                            Headers = [
+                                #"Content-Type" = "application/json"
+                            ],
+                            Content = Json.FromValue(
+                                [
+                                    refreshToken = refreshToken,
+                                    appId = "1ea917e25a",
+                                    appSecret = "7d1cb26028"
+                                ]
+                            )
+                        ]
+                    ),
+                    json = Json.Document(Source)
+                in
+                    [
+                        access_token = json[token],
+                        scope = null,
+                        token_type = "bearer",
+                        refresh_token = json[refreshToken]
+                    ],
+            Logout = (clientApplication, dataSourcePath, accessToken) =>
+                let
+                    Source = Web.Contents(
+                        Text.Combine({"https://latest.speckle.dev", "auth", "logout"}, "/"),
+                        [
+                            Headers = [
+                                #"Content-Type" = "application/json"
+                            ],
+                            Content = Json.FromValue([
+                                token = accessToken
+                            ])
+                        ]
+                    ),
+                    json = Json.Document(Source)
+                in
+                    json
+        ],
+        Key = [
+            KeyLabel = "Personal Access Token",
+            Label = "Private stream"
+        ],
+        Implicit = [
+            Label = "Public stream"
+        ]
+    ],
+    Label = "Speckle"
+];
+
+// Gets the object referenced by a specific speckle URL
+[DataSource.Kind = "Speckle", Publish = "Get.ByUrl.Publish"]
+shared Speckle.GetByUrl.Structured = Value.ReplaceType(
+    Speckle.LoadFunction("Get.ByUrl.pqm"),
+    type function (
+        url as (
+            Uri.Type meta [
+                Documentation.FieldCaption = "Gets a Speckle Object preserving it's structure",
+                Documentation.FieldDescription = "The url of a stream in a Speckle server. You can copy it directly from your browser.",
+                Documentation.SampleValues = {
+                    "https://speckle.xyz/streams/23401adf",
+                    "https://speckle.xyz/streams/23401adf/branches/main"
+                }
+            ]
+        )
+    ) as record meta [
+        Documentation.Name = "Speckle - Get Structured Object by URL",
+        Documentation.LongDescription = "Returns the Speckle object the URL points to, while also preserving it's structure.
+            Supports all types of stream url:#(lf)
+            - Stream: will get the latest commit on the 'main' branch (i.e. 'https://speckle.xyz/streams/STREAM_ID')#(lf)
+            - Branch: will get the latest commit on the specified branch (i.e. 'https://speckle.xyz/streams/STREAM_ID/branches/BRANCH_NAME')#(lf)
+            - Commit: will get a specific commit from the stream (i.e. 'https://speckle.xyz/streams/STREAM_ID/commits/COMMIT_ID')
+        "
+    ]
+);
+
+// [DataSource.Kind = "Speckle", Publish = "NavTable.Publish"]
+// shared Speckle.GetObjectAsNavTable = Value.ReplaceType(
+//     NavigationTable.Simple, type function (url as Uri.Type) as table
+// );
+// Get's a flat list of speckle objects from a URL
+[DataSource.Kind = "Speckle", Publish = "GetByUrl.Publish"]
+shared Speckle.GetByUrl = Value.ReplaceType(
+    Speckle.LoadFunction("GetByUrl.pqm"),
+    type function (
+        url as (
+            Uri.Type meta [
+                Documentation.FieldCaption = "Stream URL",
+                Documentation.FieldDescription = "The url of a stream in a Speckle server. You can copy it directly from your browser.",
+                Documentation.SampleValues = {
+                    "https://speckle.xyz/streams/23401adf",
+                    "https://speckle.xyz/streams/23401adf/branches/main"
+                }
+            ]
+        )
+    ) as table meta [
+        Documentation.Name = "Speckle - Get stream by URL",
+        Documentation.LongDescription = "Returns a flat list of all objects contained in a specific Speckle stream/branch/commit/object.
+            Supports all types of stream url:#(lf)
+            - Stream: will get the latest commit on the 'main' branch (i.e. 'https://speckle.xyz/streams/STREAM_ID')#(lf)
+            - Branch: will get the latest commit on the specified branch (i.e. 'https://speckle.xyz/streams/STREAM_ID/branches/BRANCH_NAME')#(lf)
+            - Commit: will get a specific commit from the stream (i.e. 'https://speckle.xyz/streams/STREAM_ID/commits/COMMIT_ID')
+        "
+    ]
+);
+
+// Gets the current authenticated user, if any
+[DataSource.Kind = "Speckle"]
+shared Speckle.Api.GetUser = Value.ReplaceType(
+    Speckle.LoadFunction("Api.GetUser.pqm"), type function (url as Uri.Type) as record
+);
+
+// Generic fetch function to our GraphQL endpoint
+[DataSource.Kind = "Speckle"]
+shared Speckle.Api.Fetch = Value.ReplaceType(
+    Speckle.LoadFunction("Api.Fetch.pqm"),
+    type function (url as Uri.Type, optional query as text, optional variables as record) as record
+);
+
+// Parses a stream url and returns a record with the type and values
+shared Speckle.ParseUrl = Speckle.LoadFunction("ParseStreamUrl.pqm");
+
+// [DataSource.Kind = "Speckle"]
+// shared Speckle.Api.REST.GetObject = Value.ReplaceType(
+//     Speckle.LoadFunction("Api.REST.GetObject.pqm"),
+//     type function (url as Uri.Type, optional streamId as text, optional objectId as text) as list
+// );
+Get.ByUrl.Publish = GetPublish("GetStream");
+
+NavTable.Publish = GetPublish("GetObjectAsNavTable");
+
+GetByUrl.Publish = GetPublish("GetByUrl");
+
+GetPublish = Speckle.LoadFunction("GetPublish.pqm");
+
+// Navigation table utility function
+Table.ToNavigationTable = Speckle.LoadFunction("Table.ToNavigationTable.pqm");
+
+// Function to load `pqm` files
+shared Speckle.LoadFunction = (fileName as text) =>
+    let
+        binary = Extension.Contents(fileName), asText = Text.FromBinary(binary)
+    in
+        try
+            Expression.Evaluate(asText, #shared) catch (e) =>
+                error
+                    [
+                        Reason = "Speckle.LoadFunction Failure",
+                        Message.Format = "Loading '#{0}' failed - '#{1}': '#{2}'",
+                        Message.Parameters = {fileName, e[Reason], e[Message]},
+                        Detail = [File = fileName, Error = e]
+                    ];

Speckle.proj

@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="Current" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" DefaultTargets="BuildMez">
+  <PropertyGroup>
+    <OutputPath Condition="'$(OutputPath)' == ''">$(MSBuildProjectDirectory)\bin\</OutputPath>
+    <IntermediateOutputPath Condition="'$(IntermediateOutputPath)' == ''">$(MSBuildProjectDirectory)\obj\</IntermediateOutputPath>
+    <MezIntermediatePath>$(IntermediateOutputPath)MEZ\</MezIntermediatePath>
+    <MezOutputPath>$(OutputPath)$(MsBuildProjectName).mez</MezOutputPath>
+  </PropertyGroup>
+  <ItemGroup>
+    <MezContent Include="Speckle.pq" />
+    <MezContent Include="utilities\**\*.pqm" />
+    <MezContent Include="speckle\**\*.pqm" />
+    <MezContent Include="assets\SpeckleLogo16.png" />
+    <MezContent Include="assets\SpeckleLogo20.png" />
+    <MezContent Include="assets\SpeckleLogo24.png" />
+    <MezContent Include="assets\SpeckleLogo32.png" />
+    <MezContent Include="assets\SpeckleLogo40.png" />
+    <MezContent Include="assets\SpeckleLogo48.png" />
+    <MezContent Include="assets\SpeckleLogo64.png" />
+    <MezContent Include="assets\SpeckleLogo80.png" />
+    <MezContent Include="assets\resources.resx" />
+  </ItemGroup>
+  <Target Name="BuildMez" AfterTargets="Build" Inputs="@(MezContent)" Outputs="$(MezOutputPath)">
+    <RemoveDir Directories="$(MezIntermediatePath)" />
+    <Copy SourceFiles="@(MezContent)" DestinationFolder="$(MezIntermediatePath)" />
+    <MakeDir Directories="$(OutputPath)" Condition="!Exists('$(OutputPath)')" />
+    <ZipDirectory SourceDirectory="$(MezIntermediatePath)" DestinationFile="$(MezOutputPath)" Overwrite="true" />
+  </Target>
+  <Target Name="CopyToConnectors" AfterTargets="BuildMez">
+    <Message Text="Copying .mez file to: $(UserProfile)\Documents\Power BI Desktop\Custom Connectors" Importance="High" />
+    <MakeDir Directories="$(UserProfile)\Documents\Power BI Desktop\Custom Connectors\" />
+    <Copy SourceFiles="$(MezOutputPath)" DestinationFolder="$(UserProfile)\Documents\Power BI Desktop\Custom Connectors\"/>
+  </Target>
+  <Target Name="Clean">
+    <RemoveDir Directories="$(MezIntermediatePath)" />
+    <Delete Files="$(MezOutputPath)" />
+  </Target>
+</Project>

Speckle.query.pq

@@ -0,0 +1,2 @@
+// Use this file to write queries to test your data connector
+let result = Speckle.Api.Fetch("https://latest.speckle.dev") in Record.ToTable(result)

Speckle.sln

@@ -1,25 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 16
-VisualStudioVersion = 16.0.30804.86
-MinimumVisualStudioVersion = 10.0.40219.1
-Project("{4DF76451-A46A-4C0B-BE03-459FAAFA07E6}") = "Speckle", "Speckle\Speckle.mproj", "{D61F9470-E614-45C7-8047-E354FF219408}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|x86 = Debug|x86
-		Release|x86 = Release|x86
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{D61F9470-E614-45C7-8047-E354FF219408}.Debug|x86.ActiveCfg = Debug|x86
-		{D61F9470-E614-45C7-8047-E354FF219408}.Debug|x86.Build.0 = Debug|x86
-		{D61F9470-E614-45C7-8047-E354FF219408}.Release|x86.ActiveCfg = Release|x86
-		{D61F9470-E614-45C7-8047-E354FF219408}.Release|x86.Build.0 = Release|x86
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-	GlobalSection(ExtensibilityGlobals) = postSolution
-		SolutionGuid = {765772BB-45FA-4661-9573-F0F182FEB7C1}
-	EndGlobalSection
-EndGlobal

Speckle/Speckle.mproj

@@ -1,121 +0,0 @@
-<Project DefaultTargets="BuildExtension" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{0b5fe03d-aad9-4bc4-9edf-b543d5e50d29}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <RootNamespace>MyRootNamespace</RootNamespace>
-    <AssemblyName>MyAssemblyName</AssemblyName>
-    <EnableUnmanagedDebugging>False</EnableUnmanagedDebugging>
-    <AllowNativeQuery>False</AllowNativeQuery>
-    <AsAction>False</AsAction>
-    <FastCombine>False</FastCombine>
-    <ClearLog>False</ClearLog>
-    <ShowEngineTraces>False</ShowEngineTraces>
-    <ShowUserTraces>False</ShowUserTraces>
-    <LegacyRedirects>False</LegacyRedirects>
-    <SuppressRowErrors>False</SuppressRowErrors>
-    <SuppressCellErrors>False</SuppressCellErrors>
-    <MaxRows>1000</MaxRows>
-    <ExtensionProject>Yes</ExtensionProject>
-    <Name>Speckle</Name>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
-    <DebugSymbols>false</DebugSymbols>
-    <!--Should be true, fix this when the debugger is implemented -->
-    <OutputPath>bin\Debug\</OutputPath>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
-    <DebugSymbols>false</DebugSymbols>
-    <OutputPath>bin\Release\</OutputPath>
-  </PropertyGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib" />
-    <Reference Include="System" />
-    <Reference Include="System.Data" />
-    <Reference Include="System.Xml" />
-  </ItemGroup>
-  <ItemGroup>
-    <Compile Include="Speckle.pq">
-      <SubType>Code</SubType>
-    </Compile>
-    <Compile Include="SpeckleLogo16.png">
-      <SubType>Code</SubType>
-    </Compile>
-    <Compile Include="SpeckleLogo20.png">
-      <SubType>Code</SubType>
-    </Compile>
-    <Compile Include="SpeckleLogo24.png">
-      <SubType>Code</SubType>
-    </Compile>
-    <Compile Include="SpeckleLogo32.png">
-      <SubType>Code</SubType>
-    </Compile>
-    <Compile Include="SpeckleLogo40.png">
-      <SubType>Code</SubType>
-    </Compile>
-    <Compile Include="SpeckleLogo48.png">
-      <SubType>Code</SubType>
-    </Compile>
-    <Compile Include="SpeckleLogo64.png">
-      <SubType>Code</SubType>
-    </Compile>
-    <Compile Include="SpeckleLogo80.png">
-      <SubType>Code</SubType>
-    </Compile>
-    <Compile Include="resources.resx">
-      <SubType>Code</SubType>
-    </Compile>
-    <Content Include="Speckle.query.pq">
-      <SubType>Code</SubType>
-    </Content>
-  </ItemGroup>
-  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
-  <UsingTask TaskName="BuildExtension" TaskFactory="CodeTaskFactory" AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.v12.0.dll">
-    <ParameterGroup>
-      <InputDirectory ParameterType="System.String" Required="true" />
-      <OutputFile ParameterType="System.String" Required="true" />
-    </ParameterGroup>
-    <Task>
-      <Reference Include="System.IO.Compression" />
-      <Reference Include="System.IO.Compression.FileSystem" />
-      <Using Namespace="System.Globalization" />
-      <Using Namespace="System.IO.Compression " />
-      <Code Type="Fragment" Language="cs"><![CDATA[    
-    using(FileStream fileStream = File.Create(OutputFile))
-    using(ZipArchive archiveOut = new ZipArchive(fileStream, ZipArchiveMode.Create, false))
-    {
-        foreach(string fullPath in Directory.EnumerateFiles(InputDirectory))
-        {
-            string filename = Path.GetFileName(fullPath);
-        
-            archiveOut.CreateEntryFromFile(fullPath, filename, CompressionLevel.Optimal);
-        }
-    }
-]]></Code>
-    </Task>
-  </UsingTask>
-  <Target Name="BuildExtension" DependsOnTargets="ExtensionClean">
-    <ItemGroup>
-      <PQFiles Include="@(Compile)" Condition="'%(Extension)' == '.pq'" />
-    </ItemGroup>
-    <ItemGroup>
-      <NonPQFiles Include="@(Compile)" Condition="'%(Extension)' != '.pq'" />
-    </ItemGroup>
-    <MakeDir Directories="$(IntermediateOutputPath)" />
-    <MakeDir Directories="$(OutputPath)" />
-    <Copy SourceFiles="@(NonPQFiles)" DestinationFolder="$(IntermediateOutputPath)" />
-    <Copy SourceFiles="@(PQFiles)" DestinationFiles="@(PQFiles->'$(IntermediateOutputPath)%(RecursiveDir)%(FileName).m')" />
-    <BuildExtension InputDirectory="$(IntermediateOutputPath)" OutputFile="$(OutputPath)\$(ProjectName).mez" />
-    <Message Text="Copying .mez file to: $(UserProfile)\Documents\Power BI Desktop\Custom Connectors" Importance="High" />
-    <MakeDir Directories="$(UserProfile)\Documents\Power BI Desktop\Custom Connectors\" />
-    <Copy SourceFiles="$(OutputPath)\$(ProjectName).mez" DestinationFolder="$(UserProfile)\Documents\Power BI Desktop\Custom Connectors">
-    </Copy>
-  </Target>
-  <Target Name="ExtensionClean">
-    <!-- Remove obj folder -->
-    <RemoveDir Directories="$(BaseIntermediateOutputPath)" />
-    <!-- Remove bin folder -->
-    <RemoveDir Directories="$(OutputPath)" />
-  </Target>
-</Project>

Speckle/Speckle.pq

@@ -1,201 +0,0 @@
-section Speckle;
-
-/* This is an additional nav bar that can display branches of a stream: not using this for now
-[DataSource.Kind="Speckle",  Publish="Speckle.Publish"]
-shared Speckle.Contents = Value.ReplaceType(NavigationTable.Simple, type function (url as Uri.Type) as any);
-
-// set up nav table
-shared NavigationTable.Simple = (url) as table => 
-    let
-        baseUrl = Uri.Parts(url)[Host] as text,
-        streamId = Text.Split(Uri.Parts(url)[Path], "/"){2},
-        objects = Speckle.GetBranches(baseUrl, streamId),
-        table = #table(
-        {"Name", "Key", "Data", "ItemKind", "ItemName", "IsLeaf"}, 
-        List.InsertRange(objects, List.Count(objects), {{"GetCommit", "GetCommit", Speckle.GetObjectFromObject(baseUrl, streamId), "Function", "Function", true}})
-        ),
-        NavTable = Table.ToNavigationTable(table, {"Key"}, "Name", "Data", "ItemKind", "ItemName", "IsLeaf")
-    in
-        NavTable;
-
-Speckle.GetBranches = (url, id) =>
-    let
-		Source = Web.Contents(
-		Text.Combine({"https:/", url, "graphql"}, "/"),
-		[
-			Headers=[
-				#"Method"="POST",
-				#"Content-Type"="application/json"
-			],
-			Content=Text.ToBinary("{""query"": ""query { stream( id: \"""&id&"\"" ) { branches { items { name commits { items { id message sourceApplication authorName createdAt } } } } } }""}")
-		]
-		),
-		#"JSON" = Json.Document(Source),
-        branches = #"JSON"[data][stream][branches][items],
-        branchList = List.Generate(
-            () => [x = 0, y = Speckle.GetBranchAsList(branches{x})],
-            each [x] < List.Count(branches),
-            each [x = [x] + 1, y = Speckle.GetBranchAsList(branches{x})],
-            each [y]
-        )
-	in
-		branchList;
-
-Speckle.GetBranchAsList = (branchRecord) =>
-    let
-        commits = Table.FromRecords(branchRecord[commits][items]),
-        list = {branchRecord[name], branchRecord[name], commits, "Table", "Table", true}
-    in
-        list;
-*/
-
-[DataSource.Kind="Speckle",  Publish="Speckle.Publish"]
-shared Speckle.Contents = Value.ReplaceType(CommitTable, type function (StreamUrl as Uri.Type) as any);
-
-shared CommitTable = (url) as table => 
-    let
-        // Get server and streamId, and branchName / commitId / objectid from the input url
-        server = Text.Combine({"https://", Uri.Parts(url)[Host]}),
-        segments = Text.Split(Text.AfterDelimiter(Uri.Parts(url)[Path], "/", 0), "/"),
-        streamId = segments{1},
-        branchName = if( List.Count(segments) = 4 and segments{2} = "branches" ) then segments{3} else null,
-        commitId = if (List.Count(segments) = 4 and segments{2} = "commits" ) then segments{3} else null,
-        objectId = if (List.Count(segments) = 4 and segments{2} = "objects" ) then segments{3} else null,
-        
-        commitTable = if (commitId <> null) then Speckle.GetObjectFromCommit(server, streamId, commitId)
-        else if (objectId <> null) then Speckle.GetObjectFromObject(server, streamId, objectId, false)
-        else if (branchName <> null) then #table( { "Error" }, { { "Invalid URL, use a stream or commit or object url" } } ) // currently not implemented, see reason below
-        else Speckle.GetObjectFromStream(server, streamId)
-    in
-        commitTable;
-
-Speckle.GetObjectFromStream = (server, streamId) =>
-    let
-        branchName = "main",
-        Source = Web.Contents(
-		Text.Combine({server, "graphql"}, "/"),
-		[
-			Headers=[
-				#"Method"="POST",
-				#"Content-Type"="application/json"
-			],
-			Content=Text.ToBinary("{""query"": ""query { stream( id: \"""&streamId&"\"" ) { branch (name: \"""&branchName&"\""){ commits (limit: 1) { items { referencedObject } } } } }""}")
-		]
-		),
-		#"JSON" = Json.Document(Source),
-        objectId = #"JSON"[data][stream][branch][commits][items]{0}[referencedObject],
-        objectsTable = Speckle.GetObjectFromObject(server, streamId, objectId, true)
-    in
-        objectsTable;
-
-/* Not implemented since power query M uri does not have a decode method...def not manually writing a method to handle special chars and emojis
-Speckle.GetObjectFromBranch = (server, streamId, branchName) => 
-    let
-        Source = Web.Contents(
-		Text.Combine({server, "graphql"}, "/"),
-		[
-			Headers=[
-				#"Method"="POST",
-				#"Content-Type"="application/json"
-			],
-			Content=Text.ToBinary("{""query"": ""query { stream( id: \"""&streamId&"\"" ) { branch (name: \"""&branchName&"\""){ commits (limit: 1) { items { referencedObject } } } } }""}")
-		]
-		),
-		#"JSON" = Json.Document(Source),
-        objectId = #"JSON"[data][stream][branch][commits][items]{0}[referencedObject],
-        objectsTable = Speckle.GetObjectFromObject(server, streamId, objectId)
-    in
-        objectsTable;
-*/
-
-shared Speckle.GetObjectFromCommit = (server, streamId, commitId) =>
-    let
-        Source = Web.Contents(
-		Text.Combine({server, "graphql"}, "/"),
-		[
-			Headers=[
-				#"Method"="POST",
-				#"Content-Type"="application/json"
-			],
-			Content=Text.ToBinary("{""query"": ""query { stream( id: \"""&streamId&"\"" ) { commit (id: \"""&commitId&"\""){ referencedObject } } }""}")
-		]
-		),
-		#"JSON" = Json.Document(Source),
-        objectId = #"JSON"[data][stream][commit][referencedObject],
-        objectsTable = Speckle.GetObjectFromObject(server, streamId, objectId, true)
-    in
-        objectsTable;
-
-Speckle.GetObjectFromObject = (server, streamId, objectId, IsCommitObject) => 
-    let
-        query = if (IsCommitObject) then "{""query"": ""query { stream( id: \"""&streamId&"\"" ) { object (id: \"""&objectId&"\"") { children { objects { data } } } } }""}"
-        else "{""query"": ""query { stream( id: \"""&streamId&"\"" ) { object (id: \"""&objectId&"\"") { data } } }""}",
-        Source = Web.Contents(
-		Text.Combine({server, "graphql"}, "/"),
-		[
-			Headers=[
-				#"Method"="POST",
-				#"Content-Type"="application/json"
-			],
-			Content=Text.ToBinary(query)
-		]
-		),
-		#"JSON" = Json.Document(Source),
-        objects = if (IsCommitObject) then #"JSON"[data][stream][object][children][objects]
-        else {#"JSON"[data][stream][object][data]},
-        objectsTable = Table.FromRecords(objects)
-    in
-        objectsTable;
-
-// Data Source Kind description
-Speckle = [
-    Authentication = [
-        Key = [
-            KeyLabel="Personal Access Token",
-            Label = "Private stream"
-        ],
-        Implicit = [
-            Label = "Public stream"
-        ]
-    ],
-    Label = Extension.LoadString("Speckle Connector")
-];
-
-// Data Source UI publishing description
-Speckle.Publish = [
-    Beta = true,
-    Category = "Other",
-    ButtonText = { Extension.LoadString("ButtonTitle"), Extension.LoadString("ButtonHelp") },
-    LearnMoreUrl = "https://speckle.guide",
-    SourceImage = Speckle.Icons,
-    SourceTypeImage = Speckle.Icons
-];
-
-Speckle.Icons = [
-    Icon16 = { Extension.Contents("SpeckleLogo16.png"), Extension.Contents("SpeckleLogo20.png"), Extension.Contents("SpeckleLogo24.png"), Extension.Contents("SpeckleLogo32.png") },
-    Icon32 = { Extension.Contents("SpeckleLogo32.png"), Extension.Contents("SpeckleLogo40.png"), Extension.Contents("SpeckleLogo48.png"), Extension.Contents("SpeckleLogo64.png") }
-];
-
-// copy and pasted function from microsoft docs since it's not included yet in M standard lib
-Table.ToNavigationTable = (
-    table as table,
-    keyColumns as list,
-    nameColumn as text,
-    dataColumn as text,
-    itemKindColumn as text,
-    itemNameColumn as text,
-    isLeafColumn as text
-) as table =>
-    let
-        tableType = Value.Type(table),
-        newTableType = Type.AddTableKey(tableType, keyColumns, true) meta 
-        [
-            NavigationTable.NameColumn = nameColumn, 
-            NavigationTable.DataColumn = dataColumn,
-            NavigationTable.ItemKindColumn = itemKindColumn, 
-            Preview.DelayColumn = itemNameColumn, 
-            NavigationTable.IsLeafColumn = isLeafColumn
-        ],
-        navigationTable = Value.ReplaceType(table, newTableType)
-    in
-        navigationTable;

Speckle/Speckle.query.pq

@@ -1,5 +0,0 @@
-// Use this file to write queries to test your data connector
-let
-    result = Speckle.Contents("https://speckle.xyz/streams/5dfbeb49c9/objects/ed4748572b27cfe008f2592a44ab85f1")
-in
-    result

Speckle/resources.resx

@@ -1,129 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <!-- 
-    Microsoft ResX Schema 
-    
-    Version 2.0
-    
-    The primary goals of this format is to allow a simple XML format 
-    that is mostly human readable. The generation and parsing of the 
-    various data types are done through the TypeConverter classes 
-    associated with the data types.
-    
-    Example:
-    
-    ... ado.net/XML headers & schema ...
-    <resheader name="resmimetype">text/microsoft-resx</resheader>
-    <resheader name="version">2.0</resheader>
-    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
-    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
-    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
-    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
-    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
-        <value>[base64 mime encoded serialized .NET Framework object]</value>
-    </data>
-    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
-        <comment>This is a comment</comment>
-    </data>
-                
-    There are any number of "resheader" rows that contain simple 
-    name/value pairs.
-    
-    Each data row contains a name, and value. The row also contains a 
-    type or mimetype. Type corresponds to a .NET class that support 
-    text/value conversion through the TypeConverter architecture. 
-    Classes that don't support this are serialized and stored with the 
-    mimetype set.
-    
-    The mimetype is used for serialized objects, and tells the 
-    ResXResourceReader how to depersist the object. This is currently not 
-    extensible. For a given mimetype the value must be set accordingly:
-    
-    Note - application/x-microsoft.net.object.binary.base64 is the format 
-    that the ResXResourceWriter will generate, however the reader can 
-    read any of the formats listed below.
-    
-    mimetype: application/x-microsoft.net.object.binary.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
-            : and then encoded with base64 encoding.
-    
-    mimetype: application/x-microsoft.net.object.soap.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
-            : and then encoded with base64 encoding.
-
-    mimetype: application/x-microsoft.net.object.bytearray.base64
-    value   : The object must be serialized into a byte array 
-            : using a System.ComponentModel.TypeConverter
-            : and then encoded with base64 encoding.
-    -->
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <data name="ButtonHelp" xml:space="preserve">
-    <value>Connect to Speckle</value>
-  </data>
-  <data name="ButtonTitle" xml:space="preserve">
-    <value>Speckle</value>
-  </data>
-  <data name="DataSourceLabel" xml:space="preserve">
-    <value>Speckle</value>
-  </data>
-</root>

assets/resources.resx

@@ -0,0 +1,174 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+    <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+    <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+        <xsd:import namespace="http://www.w3.org/XML/1998/namespace"/>
+        <xsd:element name="root" msdata:IsDataSet="true">
+            <xsd:complexType>
+                <xsd:choice maxOccurs="unbounded">
+                    <xsd:element name="metadata">
+                        <xsd:complexType>
+                            <xsd:sequence>
+                                <xsd:element name="value" type="xsd:string" minOccurs="0"/>
+                            </xsd:sequence>
+                            <xsd:attribute name="name" use="required" type="xsd:string"/>
+                            <xsd:attribute name="type" type="xsd:string"/>
+                            <xsd:attribute name="mimetype" type="xsd:string"/>
+                            <xsd:attribute ref="xml:space"/>
+                        </xsd:complexType>
+                    </xsd:element>
+                    <xsd:element name="assembly">
+                        <xsd:complexType>
+                            <xsd:attribute name="alias" type="xsd:string"/>
+                            <xsd:attribute name="name" type="xsd:string"/>
+                        </xsd:complexType>
+                    </xsd:element>
+                    <xsd:element name="data">
+                        <xsd:complexType>
+                            <xsd:sequence>
+                                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1"/>
+                                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2"/>
+                            </xsd:sequence>
+                            <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1"/>
+                            <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3"/>
+                            <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4"/>
+                            <xsd:attribute ref="xml:space"/>
+                        </xsd:complexType>
+                    </xsd:element>
+                    <xsd:element name="resheader">
+                        <xsd:complexType>
+                            <xsd:sequence>
+                                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1"/>
+                            </xsd:sequence>
+                            <xsd:attribute name="name" type="xsd:string" use="required"/>
+                        </xsd:complexType>
+                    </xsd:element>
+                </xsd:choice>
+            </xsd:complexType>
+        </xsd:element>
+    </xsd:schema>
+    <resheader name="resmimetype">
+        <value>text/microsoft-resx</value>
+    </resheader>
+    <resheader name="version">
+        <value>2.0</value>
+    </resheader>
+    <resheader name="reader">
+        <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+    </resheader>
+    <resheader name="writer">
+        <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+    </resheader>
+    <data name="GetByUrl.Help" xml:space="preserve">
+        <value>Connect to Speckle by Stream URL</value>
+    </data>
+    <data name="GetByUrl.Label" xml:space="preserve">
+        <value>Speckle</value>
+    </data>
+    <data name="GetByUrl.Title" xml:space="preserve">
+        <value>Speckle - Get stream by URL</value>
+    </data>
+    <data name="GetObjFromBranch.Help" xml:space="preserve">
+        <value>Connect to Speckle by serer URL, stream ID and branch name</value>
+    </data>
+    <data name="GetObjFromBranch.Label" xml:space="preserve">
+        <value>Get the latest commit from a stream's branch</value>
+    </data>
+    <data name="GetObjFromBranch.Title" xml:space="preserve">
+        <value>Speckle - Get Stream branch</value>
+    </data>
+    <data name="GetObjFromCommit.Help" xml:space="preserve">
+        <value>Connect to Speckle by server URL, stream ID and commit ID</value>
+    </data>
+    <data name="GetObjFromCommit.Label" xml:space="preserve">
+        <value>A label</value>
+    </data>
+    <data name="GetObjFromCommit.Title" xml:space="preserve">
+        <value>Speckle - Get Stream commit</value>
+    </data>
+    <data name="GetStream.Help" xml:space="preserve">
+        <value>Connect to Speckle by server URL and stream ID</value>
+    </data>
+    <data name="GetStream.Label" xml:space="preserve">
+        <value>Speckle</value>
+    </data>
+    <data name="GetStream.Title" xml:space="preserve">
+        <value>Speckle - Get Stream</value>
+    </data>
+    <data name="GetObjectAsNavTable.Title" xml:space="preserve">
+        <value>Speckle - Get Object as NavTable</value>
+    </data>
+    <data name="GetObjectAsNavTable.Label" xml:space="preserve">
+        <value>Speckle</value>
+    </data>
+    <data name="GetObjectAsNavTable.Help" xml:space="preserve">
+        <value>Returns a navigation table for a given object</value>
+    </data>
+    <data name="Traverse.Title" xml:space="preserve">
+        <value>Traverse an object and populate refs</value>
+    </data>
+    <data name="Traverse.Label" xml:space="preserve">
+        <value>Traverse</value>
+    </data>
+    <data name="Traverse.Help" xml:space="preserve">
+        <value>Traverse help</value>
+    </data>
+</root>

speckle/Get.BranchCommits.pqm

@@ -0,0 +1,48 @@
+let
+    Fetch = Extension.LoadFunction("Api.Fetch.pqm"),
+    CommitReceived = Extension.LoadFunction("Api.CommitReceived.pqm"),
+    Extension.LoadFunction = (fileName as text) =>
+        let
+            binary = Extension.Contents(fileName), asText = Text.FromBinary(binary)
+        in
+            try
+                Expression.Evaluate(asText, #shared) catch (e) =>
+                    error
+                        [
+                            Reason = "Extension.LoadFunction Failure",
+                            Message.Format = "Loading '#{0}' failed - '#{1}': '#{2}'",
+                            Message.Parameters = {fileName, e[Reason], e[Message]},
+                            Detail = [File = fileName, Error = e]
+                        ]
+in
+    (server as text, streamId as text, branchName as text, limit as number) as list =>
+        let
+            decodedBranchName = Record.Field(
+                Record.Field(Uri.Parts("http://www.dummy.com?" & Uri.BuildQueryString([A = branchName])), "Query"),
+                "A"
+            ),
+            // Hacky way to decode base64 strings: Put them in a url query param and parse the URL
+            apiKey = try Extension.CurrentCredential()[Key] otherwise null,
+            query = "query($streamId: String!, $branchName: String!, $limit: Int!) { 
+            stream( id: $streamId ) { 
+                branch (name: $branchName ){
+                    commits (limit: $limit) {
+                        items {
+                            id
+                            referencedObject
+                            sourceApplication
+                        }
+                    }
+                }
+            }
+        }",
+            res = Fetch(server, query, [streamId = streamId, branchName = decodedBranchName, limit = limit]),
+            branch = res[stream][branch],
+            commits = branch[commits][items]
+        in
+            if branch = null then
+                error Text.Format("The branch '#{0}' does not exist in stream '#{1}'", {decodedBranchName, streamId})
+            else if List.Count(branch[commits][items]) = 0 then
+                error Text.Format("The branch '#{0}' in stream #{1} has no commits", {decodedBranchName, streamId})
+            else
+                commits

speckle/Get.ByUrl.pqm

@@ -0,0 +1,42 @@
+let
+    Fetch = Extension.LoadFunction("Api.Fetch.pqm"),
+    Traverse = Extension.LoadFunction("Traverse.pqm"),
+    GetObject = Extension.LoadFunction("Api.GetObject.pqm"),
+    GetStreamCommit = Extension.LoadFunction("Get.StreamCommit.pqm"),
+    GetBranchCommits = Extension.LoadFunction("Get.BranchCommits.pqm"),
+    CommitReceived = Extension.LoadFunction("Api.CommitReceived.pqm"),
+    ParseStreamUrl = Extension.LoadFunction("ParseStreamUrl.pqm"),
+    CleanUpObject = Extension.LoadFunction("CleanUpObject.pqm"),
+    Extension.LoadFunction = (fileName as text) =>
+        let
+            binary = Extension.Contents(fileName), asText = Text.FromBinary(binary)
+        in
+            try
+                Expression.Evaluate(asText, #shared) catch (e) =>
+                    error
+                        [
+                            Reason = "Extension.LoadFunction Failure",
+                            Message.Format = "Loading '#{0}' failed - '#{1}': '#{2}'",
+                            Message.Parameters = {fileName, e[Reason], e[Message]},
+                            Detail = [File = fileName, Error = e]
+                        ]
+in
+    (url as text) as record =>
+        let
+            // Get server and streamId, and branchName / commitId / objectid from the input url
+            stream = ParseStreamUrl(url),
+            id = stream[id],
+            server = stream[server],
+            commit =
+                if (stream[urlType] = "Stream") then
+                    GetBranchCommits(server, id, "main", 1){0}
+                else if (stream[urlType] = "Branch") then
+                    GetBranchCommits(server, id, stream[branch], 1){0}
+                else if (stream[urlType] = "Commit") then
+                    GetStreamCommit(server, id, stream[commit])
+                else
+                    //We deal with object URLs directly
+                    [referencedObject = stream[object]],
+            object = GetObject(server, id, commit[referencedObject])
+        in
+            Traverse(CleanUpObject(object) meta [server = server, stream = id, commit = commit])

speckle/Get.StreamCommit.pqm

@@ -0,0 +1,36 @@
+let
+    Fetch = Extension.LoadFunction("Api.Fetch.pqm"),
+    Extension.LoadFunction = (fileName as text) =>
+        let
+            binary = Extension.Contents(fileName), asText = Text.FromBinary(binary)
+        in
+            try
+                Expression.Evaluate(asText, #shared) catch (e) =>
+                    error
+                        [
+                            Reason = "Extension.LoadFunction Failure",
+                            Message.Format = "Loading '#{0}' failed - '#{1}': '#{2}'",
+                            Message.Parameters = {fileName, e[Reason], e[Message]},
+                            Detail = [File = fileName, Error = e]
+                        ]
+in
+    (server as text, streamId as text, commitId as text) as record =>
+        let
+            apiKey = try Extension.CurrentCredential()[Key] otherwise null,
+            query = "query($streamId: String!, $commitId: String!) {
+            stream( id: $streamId ) {
+                commit (id: $commitId) {
+                    id
+                    sourceApplication
+                    referencedObject
+                }
+            }
+        }",
+            variables = [streamId = streamId, commitId = commitId],
+            #"JSON" = Fetch(server, query, variables),
+            commit = #"JSON"[stream][commit]
+        in
+            if commit = null then
+                error "The commit did not exist on this stream"
+            else
+                commit

speckle/GetApplicationSlug.pqm

@@ -0,0 +1,64 @@
+(appName as text) =>
+    let
+        replaced = Text.Replace(appName, " ", ""), name = Text.Lower(replaced)
+    in
+        if Text.Contains(name, "dynamo") then
+            "dynamo"
+        else if Text.Contains(name, "revit") then
+            "revit"
+        else if Text.Contains(name, "autocad") then
+            "autocad"
+        else if Text.Contains(name, "civil") then
+            "civil"
+        else if Text.Contains(name, "rhino") then
+            "rhino"
+        else if Text.Contains(name, "grasshopper") then
+            "grasshopper"
+        else if Text.Contains(name, "unity") then
+            "unity"
+        else if Text.Contains(name, "gsa") then
+            "gsa"
+        else if Text.Contains(name, "microstation") then
+            "microstation"
+        else if Text.Contains(name, "openroads") then
+            "openroads"
+        else if Text.Contains(name, "openrail") then
+            "openrail"
+        else if Text.Contains(name, "openbuildings") then
+            "openbuildings"
+        else if Text.Contains(name, "etabs") then
+            "etabs"
+        else if Text.Contains(name, "sap") then
+            "sap"
+        else if Text.Contains(name, "csibridge") then
+            "csibridge"
+        else if Text.Contains(name, "safe") then
+            "safe"
+        else if Text.Contains(name, "teklastructures") then
+            "teklastructures"
+        else if Text.Contains(name, "dxf") then
+            "dxf"
+        else if Text.Contains(name, "excel") then
+            "excel"
+        else if Text.Contains(name, "unreal") then
+            "unreal"
+        else if Text.Contains(name, "powerbi") then
+            "powerbi"
+        else if Text.Contains(name, "blender") then
+            "blender"
+        else if Text.Contains(name, "qgis") then
+            "qgis"
+        else if Text.Contains(name, "arcgis") then
+            "arcgis"
+        else if Text.Contains(name, "sketchup") then
+            "sketchup"
+        else if Text.Contains(name, "archicad") then
+            "archicad"
+        else if Text.Contains(name, "topsolid") then
+            "topsolid"
+        else if Text.Contains(name, "python") then
+            "python"
+        else if Text.Contains(name, "net") then
+            "net"
+        else
+            "other"

speckle/GetByUrl.pqm

@@ -0,0 +1,48 @@
+let
+    Fetch = Extension.LoadFunction("Api.Fetch.pqm"),
+    GetAllObjectChildren = Extension.LoadFunction("Api.GetAllObjectChildren.pqm"),
+    GetObjectFromCommit = Extension.LoadFunction("GetObjectFromCommit.pqm"),
+    GetObjectFromBranch = Extension.LoadFunction("GetObjectFromBranch.pqm"),
+    CommitReceived = Extension.LoadFunction("Api.CommitReceived.pqm"),
+    ParseStreamUrl = Extension.LoadFunction("ParseStreamUrl.pqm"),
+    Extension.LoadFunction = (fileName as text) =>
+        let
+            binary = Extension.Contents(fileName), asText = Text.FromBinary(binary)
+        in
+            try
+                Expression.Evaluate(asText, #shared) catch (e) =>
+                    error
+                        [
+                            Reason = "Extension.LoadFunction Failure",
+                            Message.Format = "Loading '#{0}' failed - '#{1}': '#{2}'",
+                            Message.Parameters = {fileName, e[Reason], e[Message]},
+                            Detail = [File = fileName, Error = e]
+                        ]
+in
+    (url as text) as table =>
+        let
+            // Get server and streamId, and branchName / commitId / objectid from the input url
+            stream = ParseStreamUrl(url),
+            id = stream[id],
+            server = stream[server],
+            commitObjectsTable =
+                if (stream[urlType] = "Commit") then
+                    GetObjectFromCommit(server, id, stream[commit])
+                else if (stream[urlType] = "Object") then
+                    GetAllObjectChildren(server, id, stream[object])
+                else if (stream[urlType] = "Branch") then
+                    GetObjectFromBranch(server, id, stream[branch])
+                else
+                    GetObjectFromBranch(server, id, "main"),
+            removeEmpty = Table.RemoveLastN(commitObjectsTable, 1),
+            addStreamUrl = Table.AddColumn(removeEmpty, "Stream URL", each server & "/streams/" & id),
+            addUrlType = Table.AddColumn(addStreamUrl, "URL Type", each stream[urlType]),
+            addObjectIdCol = Table.AddColumn(addUrlType, "Object ID", each try[data][id] otherwise null),
+            addSpeckleTypeCol = Table.AddColumn(
+                addObjectIdCol, "speckle_type", each try[data][speckle_type] otherwise null
+            ),
+            final = Table.ReorderColumns(
+                addSpeckleTypeCol, {"Stream URL", "URL Type", "Object ID", "speckle_type", "data"}
+            )
+        in
+            final

speckle/GetObjectFromBranch.pqm

@@ -0,0 +1,55 @@
+let
+    Fetch = Extension.LoadFunction("Api.Fetch.pqm"),
+    GetAllObjectChildren = Extension.LoadFunction("Api.GetAllObjectChildren.pqm"),
+    CommitReceived = Extension.LoadFunction("Api.CommitReceived.pqm"),
+    Extension.LoadFunction = (fileName as text) =>
+        let
+            binary = Extension.Contents(fileName), asText = Text.FromBinary(binary)
+        in
+            try
+                Expression.Evaluate(asText, #shared) catch (e) =>
+                    error
+                        [
+                            Reason = "Extension.LoadFunction Failure",
+                            Message.Format = "Loading '#{0}' failed - '#{1}': '#{2}'",
+                            Message.Parameters = {fileName, e[Reason], e[Message]},
+                            Detail = [File = fileName, Error = e]
+                        ]
+in
+    (server as text, streamId as text, branchName as text) as table =>
+        let
+            decodedBranchName = Record.Field(
+                Record.Field(Uri.Parts("http://www.dummy.com?" & Uri.BuildQueryString([A = branchName])), "Query"),
+                "A"
+            ),
+            // Hacky way to decode base64 strings: Put them in a url query param and parse the URL
+            apiKey = try Extension.CurrentCredential()[Key] otherwise null,
+            query = "query($streamId: String!, $branchName: String!) { 
+            stream( id: $streamId ) { 
+                branch (name: $branchName ){
+                    commits (limit: 1) {
+                        items {
+                            id
+                            referencedObject
+                            sourceApplication
+                        }
+                    }
+                }
+            }
+        }",
+            res = Fetch(server, query, [streamId = streamId, branchName = decodedBranchName]),
+            branch = res[stream][branch],
+            commit = branch[commits][items]{0},
+            objectsTable = GetAllObjectChildren(server, streamId, commit[referencedObject]),
+            rr = CommitReceived(server, streamId, commit)
+        in
+            if branch = null then
+                error Text.Format("The branch '#{0}' does not exist in stream '#{1}'", {decodedBranchName, streamId})
+            else if List.Count(branch[commits][items]) = 0 then
+                error Text.Format("The branch '#{0}' in stream #{1} has no commits", {decodedBranchName, streamId})
+            else
+            // Force evaluation of read receipt (ideally it should happen after fetching, but can't find a way)
+            if rr then
+                objectsTable
+            else
+                objectsTable

speckle/GetObjectFromCommit.pqm

@@ -0,0 +1,42 @@
+let
+    Fetch = Extension.LoadFunction("Api.Fetch.pqm"),
+    GetAllObjectChildren = Extension.LoadFunction("Api.GetAllObjectChildren.pqm"),
+    CommitReceived = Extension.LoadFunction("Api.CommitReceived.pqm"),
+    Extension.LoadFunction = (fileName as text) =>
+        let
+            binary = Extension.Contents(fileName), asText = Text.FromBinary(binary)
+        in
+            try
+                Expression.Evaluate(asText, #shared) catch (e) =>
+                    error
+                        [
+                            Reason = "Extension.LoadFunction Failure",
+                            Message.Format = "Loading '#{0}' failed - '#{1}': '#{2}'",
+                            Message.Parameters = {fileName, e[Reason], e[Message]},
+                            Detail = [File = fileName, Error = e]
+                        ]
+in
+    (server as text, streamId as text, commitId as text) as table =>
+        let
+            apiKey = try Extension.CurrentCredential()[Key] otherwise null,
+            query = "query($streamId: String!, $commitId: String!) {
+            stream( id: $streamId ) {
+                commit (id: $commitId) {
+                    id
+                    sourceApplication
+                    referencedObject
+                }
+            }
+        }",
+            variables = [streamId = streamId, commitId = commitId],
+            #"JSON" = Fetch(server, query, variables),
+            commit = #"JSON"[stream][commit],
+            objectsTable = GetAllObjectChildren(server, streamId, commit[referencedObject]),
+            rr = CommitReceived(server, streamId, commit)
+        in
+            if commit = null then
+                error "The commit did not exist on this stream"
+            else if rr then
+                objectsTable
+            else
+                objectsTable

speckle/api/Api.CommitReceived.pqm

@@ -0,0 +1,33 @@
+let
+    Speckle.Api.Fetch = Extension.LoadFunction("Api.Fetch.pqm"),
+    Speckle.LogEvent = Extension.LoadFunction("LogEvent.pqm"),
+    Extension.LoadFunction = (fileName as text) =>
+        let
+            binary = Extension.Contents(fileName), asText = Text.FromBinary(binary)
+        in
+            try
+                Expression.Evaluate(asText, #shared) catch (e) =>
+                    error
+                        [
+                            Reason = "Extension.LoadFunction Failure",
+                            Message.Format = "Loading '#{0}' failed - '#{1}': '#{2}'",
+                            Message.Parameters = {fileName, e[Reason], e[Message]},
+                            Detail = [File = fileName, Error = e]
+                        ]
+in
+    (server, streamId, commit) =>
+        let
+            query = "mutation($input: CommitReceivedInput!) {
+            commitReceive(input: $input) 
+        }",
+            variables = [
+                input = [
+                    streamId = streamId,
+                    commitId = commit[id],
+                    sourceApplication = "PowerBI"
+                ]
+            ],
+            s = Speckle.LogEvent(server, commit)
+        in
+            // Read receipts should fail gracefully no matter what
+            try Speckle.Api.Fetch(s, query, variables)[commitReceive] otherwise false

speckle/api/Api.Fetch.pqm

@@ -0,0 +1,33 @@
+(server as text, optional query as text, optional variables as record) as record =>
+    let
+        apiKey = try Extension.CurrentCredential()[Key] otherwise null,
+        defaultQuery = "query {
+                activeUser {
+                    email 
+                    name
+                }
+                serverInfo {
+                    name 
+                    company 
+                    version
+                }
+            }",
+        Source = Web.Contents(
+            Text.Combine({server, "graphql"}, "/"),
+            [
+                Headers = [
+                    #"Method" = "POST",
+                    #"Content-Type" = "application/json",
+                    #"Authorization" = if apiKey = null then "" else Text.Format("Bearer #{0}", {apiKey})
+                ],
+                ManualStatusHandling = {400},
+                Content = Json.FromValue([query = Text.From(query ?? defaultQuery), variables = variables])
+            ]
+        ),
+        #"JSON" = Json.Document(Source)
+    in
+        // Check if response contains errors, if so, return first error.
+        if Record.HasFields(#"JSON", {"errors"}) then
+            error #"JSON"[errors]{0}[message]
+        else
+            #"JSON"[data]

speckle/api/Api.GetAllObjectChildren.pqm

@@ -0,0 +1,35 @@
+let
+    Table.GenerateByPage = Extension.LoadFunction("Table.GenerateByPage.pqm"),
+    Speckle.Api.GetObjectChildren = Extension.LoadFunction("Api.GetObjectChildren.pqm"),
+    Extension.LoadFunction = (fileName as text) =>
+        let
+            binary = Extension.Contents(fileName), asText = Text.FromBinary(binary)
+        in
+            try
+                Expression.Evaluate(asText, #shared) catch (e) =>
+                    error
+                        [
+                            Reason = "Extension.LoadFunction Failure",
+                            Message.Format = "Loading '#{0}' failed - '#{1}': '#{2}'",
+                            Message.Parameters = {fileName, e[Reason], e[Message]},
+                            Detail = [File = fileName, Error = e]
+                        ]
+in
+    // Read all pages of data.
+    // After every page, we check the "nextCursor" record on the metadata of the previous request.
+    // Table.GenerateByPage will keep asking for more pages until we return null.
+    (server as text, streamId as text, objectId as text, optional cursor as text) as table =>
+        Table.GenerateByPage(
+            (previous) =>
+                let
+                    // if previous is null, then this is our first page of data
+                    nextCursor = if (previous = null) then cursor else Value.Metadata(previous)[Cursor]?,
+                    // if the cursor is null but the prevous page is not, we've reached the end
+                    page =
+                        if (previous <> null and nextCursor = null) then
+                            null
+                        else
+                            Speckle.Api.GetObjectChildren(server, streamId, objectId, 1000, nextCursor)
+                in
+                    page
+        ) meta [server = server, streamId = streamId, objectId = objectId]

speckle/api/Api.GetObject.pqm

@@ -0,0 +1,28 @@
+let
+    Speckle.Api.Fetch = Extension.LoadFunction("Api.Fetch.pqm"),
+    Extension.LoadFunction = (fileName as text) =>
+        let
+            binary = Extension.Contents(fileName), asText = Text.FromBinary(binary)
+        in
+            try
+                Expression.Evaluate(asText, #shared) catch (e) =>
+                    error
+                        [
+                            Reason = "Extension.LoadFunction Failure",
+                            Message.Format = "Loading '#{0}' failed - '#{1}': '#{2}'",
+                            Message.Parameters = {fileName, e[Reason], e[Message]},
+                            Detail = [File = fileName, Error = e]
+                        ]
+in
+    (server as text, streamId as text, objectId as text) =>
+        let
+            query = "query($streamId: String!, $objectId: String!) { 
+            stream( id: $streamId ) { 
+                object (id: $objectId) { 
+                    data
+                }
+            }
+        }",
+            #"JSON" = Speckle.Api.Fetch(server, query, [streamId = streamId, objectId = objectId])
+        in
+            #"JSON"[stream][object][data]

speckle/api/Api.GetObjectChildren.pqm

@@ -0,0 +1,54 @@
+let
+    Speckle.Api.Fetch = Extension.LoadFunction("Api.Fetch.pqm"),
+    Speckle.CleanUpObjects = Extension.LoadFunction("CleanUpObjects.pqm"),
+    Extension.LoadFunction = (fileName as text) =>
+        let
+            binary = Extension.Contents(fileName), asText = Text.FromBinary(binary)
+        in
+            try
+                Expression.Evaluate(asText, #shared) catch (e) =>
+                    error
+                        [
+                            Reason = "Extension.LoadFunction Failure",
+                            Message.Format = "Loading '#{0}' failed - '#{1}': '#{2}'",
+                            Message.Parameters = {fileName, e[Reason], e[Message]},
+                            Detail = [File = fileName, Error = e]
+                        ]
+in
+    (
+        server as text,
+        streamId as text,
+        objectId as text,
+        optional limit as number,
+        optional cursor as text,
+        optional select as list
+    ) =>
+        let
+            query = "query($streamId: String!, $objectId: String!, $limit: Int, $cursor: String, $select: [String]) { 
+            stream( id: $streamId ) { 
+                object (id: $objectId) { 
+                    children(select: $select, limit: $limit, cursor: $cursor) { 
+                        cursor
+                        objects {
+                            data
+                        } 
+                    } 
+                } 
+            } 
+        }",
+            #"JSON" = Speckle.Api.Fetch(
+                server,
+                query,
+                [
+                    streamId = streamId,
+                    objectId = objectId,
+                    limit = limit,
+                    cursor = cursor,
+                    select = select
+                ]
+            ),
+            children = #"JSON"[stream][object][children],
+            nextCursor = children[cursor],
+            clean = Speckle.CleanUpObjects(children[objects])
+        in
+            Table.FromRecords(clean) meta [Cursor = nextCursor]

speckle/api/Api.GetUser.pqm

@@ -0,0 +1,24 @@
+(url as text) =>
+    let
+        query = "query {
+            activeUser { name email }
+        }",
+        // Imports
+        Speckle.Api.Fetch = Extension.LoadFunction("Api.Fetch.pqm"),
+        server = Extension.LoadFunction("ParseStreamUrl.pqm"),
+        Extension.LoadFunction = (fileName as text) =>
+            let
+                binary = Extension.Contents(fileName), asText = Text.FromBinary(binary)
+            in
+                try
+                    Expression.Evaluate(asText, #shared) catch (e) =>
+                        error
+                            [
+                                Reason = "Extension.LoadFunction Failure",
+                                Message.Format = "Loading '#{0}' failed - '#{1}': '#{2}'",
+                                Message.Parameters = {fileName, e[Reason], e[Message]},
+                                Detail = [File = fileName, Error = e]
+                            ]
+    in
+        // Read receipts should fail gracefully no matter what
+        try Speckle.Api.Fetch(server, query)[activeUser][email] otherwise "hey"

speckle/api/Api.REST.GetObject.pqm

@@ -0,0 +1,38 @@
+(server as text, optional streamId as text, optional objectId as text) as table =>
+    let
+        apiKey = try Extension.CurrentCredential()[Key] otherwise null,
+        Source = Web.Contents(
+            Text.Combine({server, "objects", streamId, objectId}, "/"),
+            [
+                Headers = [
+                    #"Method" = "GET",
+                    #"Content-Type" = "application/json",
+                    #"Authorization" = if apiKey = null then "" else Text.Format("Bearer #{0}", {apiKey})
+                ],
+                ManualStatusHandling = {400}
+            ]
+        ),
+        json = Json.Document(Source),
+        clean = List.Select(json, each _[speckle_type] <> "Speckle.Core.Models.DataChunk"),
+        t = Table.FromColumns({clean}, {"data"}),
+        addStreamUrl = Table.AddColumn(t, "Stream URL", each server & "/streams/" & streamId),
+        addObjectIdCol = Table.AddColumn(addStreamUrl, "Object ID", each try _[data][id] otherwise null),
+        addSpeckleTypeCol = Table.AddColumn(
+            addObjectIdCol, "speckle_type", each try _[data][speckle_type] otherwise null
+        ),
+        Speckle.CleanUpObjects = Extension.LoadFunction("CleanUpObjects.pqm"),
+        Extension.LoadFunction = (fileName as text) =>
+            let
+                binary = Extension.Contents(fileName), asText = Text.FromBinary(binary)
+            in
+                try
+                    Expression.Evaluate(asText, #shared) catch (e) =>
+                        error
+                            [
+                                Reason = "Extension.LoadFunction Failure",
+                                Message.Format = "Loading '#{0}' failed - '#{1}': '#{2}'",
+                                Message.Parameters = {fileName, e[Reason], e[Message]},
+                                Detail = [File = fileName, Error = e]
+                            ]
+    in
+        addSpeckleTypeCol

speckle/helpers/CleanUpObject.pqm

@@ -0,0 +1,7 @@
+(object as record) as record =>
+    let
+        hiddenFields = {"__closure", "totalChildrenCount"},
+        // remove closures from records
+        clean = Record.RemoveFields(object, hiddenFields, MissingField.Ignore)
+    in
+        clean

speckle/helpers/CleanUpObjects.pqm

@@ -0,0 +1,17 @@
+(objects as list) as list =>
+    let
+        // remove closures from records, and remove DataChunk records
+        removeClosureField = List.Transform(
+            objects, each [data = Record.RemoveFields(_[data], "__closure", MissingField.Ignore)]
+        ),
+        removeTotals = List.Transform(
+            removeClosureField,
+            each
+                [
+                    data = try
+                        Record.RemoveFields(_[data], "totalChildrenCount", MissingField.Ignore) otherwise _[data]
+                ]
+        ),
+        removed = List.Select(removeTotals, each _[data][speckle_type] <> "Speckle.Core.Models.DataChunk")
+    in
+        removed

speckle/helpers/GetPublish.pqm

@@ -0,0 +1,30 @@
+let
+    beta = true,
+    category = "Other",
+    icons = [
+        Icon16 = {
+            Extension.Contents("SpeckleLogo16.png"),
+            Extension.Contents("SpeckleLogo20.png"),
+            Extension.Contents("SpeckleLogo24.png"),
+            Extension.Contents("SpeckleLogo32.png")
+        },
+        Icon32 = {
+            Extension.Contents("SpeckleLogo32.png"),
+            Extension.Contents("SpeckleLogo40.png"),
+            Extension.Contents("SpeckleLogo48.png"),
+            Extension.Contents("SpeckleLogo64.png")
+        }
+    ]
+in
+    (key as text) as record =>
+        [
+            Beta = beta,
+            Category = category,
+            ButtonText = {
+                Extension.LoadString(Text.Format("#{0}.Title", {key})),
+                Extension.LoadString(Text.Format("#{0}.Label", {key}))
+            },
+            LearnMoreUrl = "https://speckle.guide",
+            SourceImage = icons,
+            SourceTypeImage = icons
+        ]

speckle/helpers/LogEvent.pqm

@@ -0,0 +1,48 @@
+let
+    GetApplicationSlug = Extension.LoadFunction("GetApplicationSlug.pqm"),
+    GetUser = Extension.LoadFunction("GetUser.pqm"),
+    Hash = Extension.LoadFunction("Hash.pqm"),
+    Extension.LoadFunction = (fileName as text) =>
+        let
+            binary = Extension.Contents(fileName), asText = Text.FromBinary(binary)
+        in
+            try
+                Expression.Evaluate(asText, #shared) catch (e) =>
+                    error
+                        [
+                            Reason = "Extension.LoadFunction Failure",
+                            Message.Format = "Loading '#{0}' failed - '#{1}': '#{2}'",
+                            Message.Parameters = {fileName, e[Reason], e[Message]},
+                            Detail = [File = fileName, Error = e]
+                        ]
+in
+    (server as text, commit as any) =>
+        let
+            trackUrl = "https://analytics.speckle.systems/track?ip=1",
+            user = GetUser(server),
+            body = [
+                event = "Receive",
+                properties = [
+                    server_id = Hash(server),
+                    token = "acd87c5a50b56df91a795e999812a3a4",
+                    hostApp = "powerbi",
+                    sourceHostApp = GetApplicationSlug(commit[sourceApplication]),
+                    sourceHostAppVersion = commit[sourceApplication]
+                ]
+            ],
+            Result = Web.Contents(
+                trackUrl,
+                [
+                    Headers = [
+                        #"Method" = "POST",
+                        #"Accept" = "text/plain",
+                        #"Content-Type" = "application/json"
+                    ],
+                    Content = Text.ToBinary(Text.Combine({"data=", Text.FromBinary(Json.FromValue(body))}))
+                ]
+            ),
+            // Hack to force execution
+            Join = Text.Combine({server, Text.From(Json.Document(Result))}, "_____"),
+            Disjoin = Text.Split(Join, "_____"){0}
+        in
+            Disjoin

speckle/helpers/ParseStreamUrl.pqm

@@ -0,0 +1,27 @@
+(url as text) as record =>
+    let
+        // Get server and streamId, and branchName / commitId / objectid from the input url
+        server = Text.Combine({"https://", Uri.Parts(url)[Host]}),
+        segments = Text.Split(Text.AfterDelimiter(Uri.Parts(url)[Path], "/", 0), "/"),
+        streamId = segments{1},
+        branchName = if (List.Count(segments) = 4 and segments{2} = "branches") then segments{3} else null,
+        commitId = if (List.Count(segments) = 4 and segments{2} = "commits") then segments{3} else null,
+        objectId = if (List.Count(segments) = 4 and segments{2} = "objects") then segments{3} else null,
+        urlType =
+            if (commitId <> null) then
+                "Commit"
+            else if (objectId <> null) then
+                "Object"
+            else if (branchName <> null) then
+                "Branch"
+            else
+                "Stream"
+    in
+        [
+            urlType = urlType,
+            server = server,
+            id = streamId,
+            branch = branchName,
+            commit = commitId,
+            object = objectId
+        ]

speckle/helpers/Traverse.pqm

@@ -0,0 +1,67 @@
+let
+    GetObject = Extension.LoadFunction("Api.GetObject.pqm"),
+    Diagnostics.Log = Extension.LoadFunction("Diagnostics.pqm")[LogValue],
+    Extension.LoadFunction = (fileName as text) =>
+        let
+            binary = Extension.Contents(fileName), asText = Text.FromBinary(binary)
+        in
+            try
+                Expression.Evaluate(asText, #shared) catch (e) =>
+                    error
+                        [
+                            Reason = "Extension.LoadFunction Failure",
+                            Message.Format = "Loading '#{0}' failed - '#{1}': '#{2}'",
+                            Message.Parameters = {fileName, e[Reason], e[Message]},
+                            Detail = [File = fileName, Error = e]
+                        ],
+    //TODO: Not implemented yet
+    TraverseTable = (item as table) as table => item,
+    // Will traverse an undetermined value (list, table, record).
+    TraverseValue = (i as any) as any =>
+        let
+            item = Diagnostics.Log("Traverse value", i) meta Value.Metadata(i)
+        in
+            if Value.Is(item, type list) then
+                // Return a transformed list by traversing all items
+                Diagnostics.Log(
+                    "List travered",
+                    List.Transform(item, (a) => @TraverseValue(Value.ReplaceMetadata(a, Value.Metadata(i))))
+                )
+            else if Value.Is(item, type record) then
+                // Traverse this record individually
+                TraverseRecord(item)
+            else if Value.Is(item, type table) then
+                // Traverse this table
+                TraverseTable(item)
+            else
+                // If none of the above, assume it's just a primitive type and return it as-is.
+                item,
+    // Traverses a generic record
+    TraverseRecord = (object as record) as any =>
+        let
+            isSpeckle = Diagnostics.Log("Is Speckle", Record.HasFields(object, {"speckle_type"})),
+            isReference = Diagnostics.Log("Is Reference", object[speckle_type] = "reference"),
+            // Get the names of all fields
+            fields = Record.FieldNames(object),
+            // Remove all known fields that don't need traversing
+            cleanFields = List.RemoveItems(fields, {"id", "speckle_type", "applicationId"}),
+            // Transform the list of field names into a set of transform operations
+            transformOps = List.Transform(
+                cleanFields, each {_, (a) => TraverseValue(Value.ReplaceMetadata(a, Value.Metadata(object)))}
+            ),
+            // Get the object's metadata (server and stream will be saved in here)
+            info = Value.Metadata(object)
+        in
+            // Transform all fields and return the modified object
+            if (isReference) then
+                // Swap reference for call to GetObject
+                () =>
+                    TraverseValue(
+                        Value.ReplaceMetadata(
+                            GetObject(info[server], info[stream], object[referencedId]), Value.Metadata(object)
+                        )
+                    )
+            else
+                try Record.TransformFields(object, transformOps, MissingField.Error) otherwise error "oopsies"
+in
+    TraverseValue

tests/api/api.fetch.test.pq

@@ -0,0 +1,2 @@
+// Use this file to write queries to test your data connector
+let result = Speckle.Api.Fetch("https://latest.speckle.dev") in Record.ToTable(result)

tests/api/api.rest.getobject.test.pq

@@ -0,0 +1,7 @@
+// Use this file to write queries to test your data connector
+let
+    result = Speckle.Api.REST.GetObject(
+        "https://latest.speckle.dev", "5f284e5c70", "85e5f250fe591ea74d8d5dc1137a9341"
+    )
+in
+    result

tests/demo.test.pq

@@ -0,0 +1,30 @@
+section UnitTestingUnitTests;
+
+UT = Speckle.LoadFunction("Facts.pqm");
+Fact = UT[Fact];
+
+Facts.Summarize = UT[SummarizeFacts];
+
+shared Speckle.UnitTest = [
+    // Put any common variables here if you only want them to be evaluated once
+    // Fact(<Name of the Test>, <Expected Value>, <Actual Value>)
+    // <Expected Value> and <Actual Value> can be a literal or let statement
+    facts = {
+        Fact(
+            "Check that this function returns 'ABC'",
+            // name of the test
+            "ABC",
+            // expected value
+            UnitTesting.ReturnsABC()
+            // expression to evaluate (let or single statement)
+        ),
+        Fact("Check that this function returns '123'", "123", UnitTesting.Returns123()),
+        Fact("Result should contain 5 rows", 5, Table.RowCount(UnitTesting.ReturnsTableWithFiveRows())),
+        Fact("Values should be equal (using a let statement)", "Hello World", let a = "Hello World" in a)
+    },
+    report = Facts.Summarize(facts)
+][report];
+
+shared UnitTesting.ReturnsABC = () => "ABC";
+shared UnitTesting.Returns123 = () => "123";
+shared UnitTesting.ReturnsTableWithFiveRows = () => Table.Repeat(#table({"a"}, {{1}}), 5);

tests/get.byurl.test.pq

@@ -0,0 +1,2 @@
+// Use this file to write queries to test your data connector
+let result = Speckle.Get.ByUrl("https://latest.speckle.dev/streams/3d25474a18") in Record.ToTable(result)

tests/getbyurl.test.pq

@@ -0,0 +1,2 @@
+// Use this file to write queries to test your data connector
+let result = Speckle.GetByUrl("https://latest.speckle.dev/streams/5f284e5c70/objects/85e5f250fe591ea74d8d5dc1137a9341") in result

utilities/Diagnostics.pqm

@@ -0,0 +1,376 @@
+let
+    Diagnostics.LogValue = (prefix, value) =>
+        Diagnostics.Trace(
+            TraceLevel.Information,
+            prefix & ": " & (try Diagnostics.ValueToText(value) otherwise "<error getting value>"),
+            value
+        ),
+    Diagnostics.LogValue2 = (prefix, value, result, optional delayed) =>
+        Diagnostics.Trace(TraceLevel.Information, prefix & ": " & Diagnostics.ValueToText(value), result, delayed),
+    Diagnostics.LogFailure = (text, function) =>
+        let
+            result = try function()
+        in
+            if result[HasError] then
+                Diagnostics.LogValue2(text, result[Error], () => error result[Error], true)
+            else
+                result[Value],
+    Diagnostics.WrapFunctionResult = (innerFunction as function, outerFunction as function) as function =>
+        Function.From(Value.Type(innerFunction), (list) => outerFunction(() => Function.Invoke(innerFunction, list))),
+    Diagnostics.WrapHandlers = (handlers as record) as record =>
+        Record.FromList(
+            List.Transform(
+                Record.FieldNames(handlers),
+                (h) =>
+                    Diagnostics.WrapFunctionResult(Record.Field(handlers, h), (fn) => Diagnostics.LogFailure(h, fn))
+            ),
+            Record.FieldNames(handlers)
+        ),
+    Diagnostics.ValueToText = (value) =>
+        let
+            _canBeIdentifier = (x) =>
+                let
+                    keywords = {
+                        "and",
+                        "as",
+                        "each",
+                        "else",
+                        "error",
+                        "false",
+                        "if",
+                        "in",
+                        "is",
+                        "let",
+                        "meta",
+                        "not",
+                        "otherwise",
+                        "or",
+                        "section",
+                        "shared",
+                        "then",
+                        "true",
+                        "try",
+                        "type"
+                    },
+                    charAlpha = (c as number) => (c >= 65 and c <= 90) or (c >= 97 and c <= 122) or c = 95,
+                    charDigit = (c as number) => c >= 48 and c <= 57
+                in
+                    try
+                        charAlpha(Character.ToNumber(Text.At(x, 0)))
+                        and List.MatchesAll(
+                            Text.ToList(x), (c) => let num = Character.ToNumber(c) in charAlpha(num)
+                            or charDigit(num)
+                        )
+                        and not List.MatchesAny(keywords, (li) => li = x) otherwise false,
+            Serialize.Binary = (x) => "#binary(" & Serialize(Binary.ToList(x)) & ") ",
+            Serialize.Date = (x) =>
+                "#date(" & Text.From(Date.Year(x)) & ", " & Text.From(Date.Month(x)) & ", " & Text.From(Date.Day(x))
+                    & ") ",
+            Serialize.Datetime = (x) =>
+                "#datetime("
+                    & Text.From(Date.Year(DateTime.Date(x)))
+                    & ", "
+                    & Text.From(Date.Month(DateTime.Date(x)))
+                    & ", "
+                    & Text.From(Date.Day(DateTime.Date(x)))
+                    & ", "
+                    & Text.From(Time.Hour(DateTime.Time(x)))
+                    & ", "
+                    & Text.From(Time.Minute(DateTime.Time(x)))
+                    & ", "
+                    & Text.From(Time.Second(DateTime.Time(x)))
+                    & ") ",
+            Serialize.Datetimezone = (x) =>
+                let
+                    dtz = DateTimeZone.ToRecord(x)
+                in
+                    "#datetimezone("
+                        & Text.From(dtz[Year])
+                        & ", "
+                        & Text.From(dtz[Month])
+                        & ", "
+                        & Text.From(dtz[Day])
+                        & ", "
+                        & Text.From(dtz[Hour])
+                        & ", "
+                        & Text.From(dtz[Minute])
+                        & ", "
+                        & Text.From(dtz[Second])
+                        & ", "
+                        & Text.From(dtz[ZoneHours])
+                        & ", "
+                        & Text.From(dtz[ZoneMinutes])
+                        & ") ",
+            Serialize.Duration = (x) =>
+                let
+                    dur = Duration.ToRecord(x)
+                in
+                    "#duration("
+                        & Text.From(dur[Days])
+                        & ", "
+                        & Text.From(dur[Hours])
+                        & ", "
+                        & Text.From(dur[Minutes])
+                        & ", "
+                        & Text.From(dur[Seconds])
+                        & ") ",
+            Serialize.Function = (x) =>
+                _serialize_function_param_type(
+                    Type.FunctionParameters(Value.Type(x)), Type.FunctionRequiredParameters(Value.Type(x))
+                )
+                    & " as "
+                    & _serialize_function_return_type(Value.Type(x))
+                    & " => (...) ",
+            Serialize.List = (x) =>
+                "{"
+                    & List.Accumulate(
+                        x, "", (seed, item) => if seed = "" then Serialize(item) else seed & ", " & Serialize(item)
+                    )
+                    & "} ",
+            Serialize.Logical = (x) => Text.From(x),
+            Serialize.Null = (x) => "null",
+            Serialize.Number = (x) =>
+                let
+                    Text.From = (i as number) as text =>
+                        if Number.IsNaN(i) then
+                            "#nan"
+                        else if i = Number.PositiveInfinity then
+                            "#infinity"
+                        else if i = Number.NegativeInfinity then
+                            "-#infinity"
+                        else
+                            Text.From(i)
+                in
+                    Text.From(x),
+            Serialize.Record = (x) =>
+                "[ "
+                    & List.Accumulate(
+                        Record.FieldNames(x),
+                        "",
+                        (seed, item) =>
+                            (if seed = "" then Serialize.Identifier(item) else seed & ", " & Serialize.Identifier(
+                                item
+                            ))
+                                & " = "
+                                & Serialize(Record.Field(x, item))
+                    )
+                    & " ] ",
+            Serialize.Table = (x) =>
+                "#table( type " & _serialize_table_type(Value.Type(x)) & ", " & Serialize(Table.ToRows(x)) & ") ",
+            Serialize.Text = (x) => """" & _serialize_text_content(x) & """",
+            _serialize_text_content = (x) =>
+                let
+                    escapeText = (n as number) as text =>
+                        "#(#)(" & Text.PadStart(Number.ToText(n, "X", "en-US"), 4, "0") & ")"
+                in
+                    List.Accumulate(
+                        List.Transform(
+                            Text.ToList(x),
+                            (c) =>
+                                let
+                                    n = Character.ToNumber(c)
+                                in
+                                    if n = 9 then
+                                        "#(#)(tab)"
+                                    else if n = 10 then
+                                        "#(#)(lf)"
+                                    else if n = 13 then
+                                        "#(#)(cr)"
+                                    else if n = 34 then
+                                        """"""
+                                    else if n = 35 then
+                                        "#(#)(#)"
+                                    else if n < 32 then
+                                        escapeText(n)
+                                    else if n < 127 then
+                                        Character.FromNumber(n)
+                                    else
+                                        escapeText(n)
+                        ),
+                        "",
+                        (s, i) => s & i
+                    ),
+            Serialize.Identifier = (x) => if _canBeIdentifier(x) then x else "#""" & _serialize_text_content(x) & """",
+            Serialize.Time = (x) =>
+                "#time("
+                    & Text.From(Time.Hour(x))
+                    & ", "
+                    & Text.From(Time.Minute(x))
+                    & ", "
+                    & Text.From(Time.Second(x))
+                    & ") ",
+            Serialize.Type = (x) => "type " & _serialize_typename(x),
+            _serialize_typename = (x, optional funtype as logical) =>
+                /* Optional parameter: Is this being used as part of a function signature? */ let
+                    isFunctionType = (x as type) =>
+                        try if Type.FunctionReturn(x) is type then true else false otherwise false,
+                    isTableType = (x as type) =>
+                        try if Type.TableSchema(x) is table then true else false otherwise false,
+                    isRecordType = (x as type) =>
+                        try if Type.ClosedRecord(x) is type then true else false otherwise false,
+                    isListType = (x as type) => try if Type.ListItem(x) is type then true else false otherwise false
+                in
+                    if funtype = null and isTableType(x) then
+                        _serialize_table_type(x)
+                    else if funtype = null and isListType(x) then
+                        "{ " & @_serialize_typename(Type.ListItem(x)) & " }"
+                    else if funtype = null and isFunctionType(x) then
+                        "function " & _serialize_function_type(x)
+                    else if funtype = null and isRecordType(x) then
+                        _serialize_record_type(x)
+                    else if x = type any then
+                        "any"
+                    else
+                        let
+                            base = Type.NonNullable(x)
+                        in
+                            (if Type.IsNullable(x) then "nullable " else "")
+                                & (
+                                    if base = type anynonnull then
+                                        "anynonnull"
+                                    else if base = type binary then
+                                        "binary"
+                                    else if base = type date then
+                                        "date"
+                                    else if base = type datetime then
+                                        "datetime"
+                                    else if base = type datetimezone then
+                                        "datetimezone"
+                                    else if base = type duration then
+                                        "duration"
+                                    else if base = type logical then
+                                        "logical"
+                                    else if base = type none then
+                                        "none"
+                                    else if base = type null then
+                                        "null"
+                                    else if base = type number then
+                                        "number"
+                                    else if base = type text then
+                                        "text"
+                                    else if base = type time then
+                                        "time"
+                                    else if base = type type then
+                                        "type"
+                                    else /* Abstract types: */ if base = type function then
+                                        "function"
+                                    else if base = type table then
+                                        "table"
+                                    else if base = type record then
+                                        "record"
+                                    else if base = type list then
+                                        "list"
+                                    else
+                                        "any /*Actually unknown type*/"
+                                ),
+            _serialize_table_type = (x) =>
+                let
+                    schema = Type.TableSchema(x)
+                in
+                    "table "
+                        & (
+                            if Table.IsEmpty(schema) then
+                                ""
+                            else
+                                "["
+                                    & List.Accumulate(
+                                        List.Transform(
+                                            Table.ToRecords(Table.Sort(schema, "Position")),
+                                            each Serialize.Identifier(_[Name]) & " = " & _[Kind]
+                                        ),
+                                        "",
+                                        (seed, item) => (if seed = "" then item else seed & ", " & item)
+                                    )
+                                    & "] "
+                        ),
+            _serialize_record_type = (x) =>
+                let
+                    flds = Type.RecordFields(x)
+                in
+                    if Record.FieldCount(flds) = 0 then
+                        "record"
+                    else
+                        "["
+                            & List.Accumulate(
+                                Record.FieldNames(flds),
+                                "",
+                                (seed, item) =>
+                                    seed
+                                        & (if seed <> "" then ", " else "")
+                                        & (
+                                            Serialize.Identifier(item)
+                                                & "="
+                                                & _serialize_typename(Record.Field(flds, item)[Type])
+                                        )
+                            )
+                            & (if Type.IsOpenRecord(x) then ",..." else "")
+                            & "]",
+            _serialize_function_type = (x) =>
+                _serialize_function_param_type(Type.FunctionParameters(x), Type.FunctionRequiredParameters(x))
+                    & " as "
+                    & _serialize_function_return_type(x),
+            _serialize_function_param_type = (t, n) =>
+                let
+                    funsig = Table.ToRecords(
+                        Table.TransformColumns(
+                            Table.AddIndexColumn(Record.ToTable(t), "isOptional", 1), {"isOptional", (x) => x > n}
+                        )
+                    )
+                in
+                    "("
+                        & List.Accumulate(
+                            funsig,
+                            "",
+                            (seed, item) =>
+                                (if seed = "" then "" else seed & ", ")
+                                    & (if item[isOptional] then "optional " else "")
+                                    & Serialize.Identifier(item[Name])
+                                    & " as "
+                                    & _serialize_typename(item[Value], true)
+                        )
+                        & ")",
+            _serialize_function_return_type = (x) => _serialize_typename(Type.FunctionReturn(x), true),
+            Serialize = (x) as text =>
+                if x is binary then
+                    try Serialize.Binary(x) otherwise "null /*serialize failed*/"
+                else if x is date then
+                    try Serialize.Date(x) otherwise "null /*serialize failed*/"
+                else if x is datetime then
+                    try Serialize.Datetime(x) otherwise "null /*serialize failed*/"
+                else if x is datetimezone then
+                    try Serialize.Datetimezone(x) otherwise "null /*serialize failed*/"
+                else if x is duration then
+                    try Serialize.Duration(x) otherwise "null /*serialize failed*/"
+                else if x is function then
+                    try Serialize.Function(x) otherwise "null /*serialize failed*/"
+                else if x is list then
+                    try Serialize.List(x) otherwise "null /*serialize failed*/"
+                else if x is logical then
+                    try Serialize.Logical(x) otherwise "null /*serialize failed*/"
+                else if x is null then
+                    try Serialize.Null(x) otherwise "null /*serialize failed*/"
+                else if x is number then
+                    try Serialize.Number(x) otherwise "null /*serialize failed*/"
+                else if x is record then
+                    try Serialize.Record(x) otherwise "null /*serialize failed*/"
+                else if x is table then
+                    try Serialize.Table(x) otherwise "null /*serialize failed*/"
+                else if x is text then
+                    try Serialize.Text(x) otherwise "null /*serialize failed*/"
+                else if x is time then
+                    try Serialize.Time(x) otherwise "null /*serialize failed*/"
+                else if x is type then
+                    try Serialize.Type(x) otherwise "null /*serialize failed*/"
+                else
+                    "[#_unable_to_serialize_#]"
+        in
+            try Serialize(value) otherwise "<serialization failed>"
+in
+    [
+        LogValue = Diagnostics.LogValue,
+        LogValue2 = Diagnostics.LogValue2,
+        LogFailure = Diagnostics.LogFailure,
+        WrapFunctionResult = Diagnostics.WrapFunctionResult,
+        WrapHandlers = Diagnostics.WrapHandlers,
+        ValueToText = Diagnostics.ValueToText
+    ]

utilities/Extension.LoadFunction.pqm

@@ -0,0 +1,17 @@
+// This is here as reference for copy/pasting wherever there is need for importing pqm files.
+let
+    Extension.LoadFunction = (fileName as text) =>
+        let
+            binary = Extension.Contents(fileName), asText = Text.FromBinary(binary)
+        in
+            try
+                Expression.Evaluate(asText, #shared) catch (e) =>
+                    error
+                        [
+                            Reason = "Extension.LoadFunction Failure",
+                            Message.Format = "Loading '#{0}' failed - '#{1}': '#{2}'",
+                            Message.Parameters = {fileName, e[Reason], e[Message]},
+                            Detail = [File = fileName, Error = e]
+                        ]
+in
+    Extension.LoadFunction

utilities/Facts.pqm

@@ -0,0 +1,231 @@
+let
+    /// COMMON UNIT TESTING CODE
+    Fact = (_subject as text, _expected, _actual) as record =>
+        [
+            expected = try _expected,
+            safeExpected = if expected[HasError] then "Expected : " & @ValueToText(expected[Error]) else expected[
+                Value
+            ],
+            actual = try _actual,
+            safeActual = if actual[HasError] then "Actual : " & @ValueToText(actual[Error]) else actual[Value],
+            attempt = try safeExpected = safeActual,
+            result = if attempt[HasError] or not attempt[Value] then "Failure" else "Success",
+            resultOp = if result = "Success" then " = " else " <> ",
+            addendumEvalAttempt = if attempt[HasError] then @ValueToText(attempt[Error]) else "",
+            addendumEvalExpected = try @ValueToText(safeExpected) otherwise "...",
+            addendumEvalActual = try @ValueToText(safeActual) otherwise "...",
+            fact = [
+                Result = result & " " & addendumEvalAttempt,
+                Notes = _subject,
+                Details = " (" & addendumEvalExpected & resultOp & addendumEvalActual & ")"
+            ]
+        ][fact],
+    Facts = (_subject as text, _predicates as list) => List.Transform(_predicates, each Fact(_subject, _{0}, _{1})),
+    Facts.Summarize = (_facts as list) as table =>
+        [
+            Fact.CountSuccesses = (count, i) =>
+                [
+                    result = try i[Result],
+                    sum = if result[HasError] or not Text.StartsWith(result[Value], "Success") then count else count + 1
+                ][sum],
+            passed = List.Accumulate(_facts, 0, Fact.CountSuccesses),
+            total = List.Count(_facts),
+            format = if passed = total then "All #{0} Passed !!!" else "#{0} Passed - #{1} Failed",
+            result = if passed = total then "Success" else "Failed",
+            rate = Number.IntegerDivide(100 * passed, total),
+            header = [
+                Result = result,
+                Notes = Text.Format(format, {passed, total - passed}),
+                Details = Text.Format("#{0}% success rate", {rate})
+            ],
+            report = Table.FromRecords(List.Combine({{header}, _facts}))
+        ][report],
+    ValueToText = (value, optional depth) =>
+        let
+            List.TransformAndCombine = (list, transform, separator) =>
+                Text.Combine(List.Transform(list, transform), separator),
+            Serialize.Binary = (x) => "#binary(" & Serialize(Binary.ToList(x)) & ") ",
+            Serialize.Function = (x) =>
+                _serialize_function_param_type(
+                    Type.FunctionParameters(Value.Type(x)), Type.FunctionRequiredParameters(Value.Type(x))
+                )
+                    & " as "
+                    & _serialize_function_return_type(Value.Type(x))
+                    & " => (...) ",
+            Serialize.List = (x) => "{" & List.TransformAndCombine(x, Serialize, ", ") & "} ",
+            Serialize.Record = (x) =>
+                "[ "
+                    & List.TransformAndCombine(
+                        Record.FieldNames(x),
+                        (item) => Serialize.Identifier(item) & " = " & Serialize(Record.Field(x, item)),
+                        ", "
+                    )
+                    & " ] ",
+            Serialize.Table = (x) =>
+                "#table( type " & _serialize_table_type(Value.Type(x)) & ", " & Serialize(Table.ToRows(x)) & ") ",
+            Serialize.Identifier = Expression.Identifier,
+            Serialize.Type = (x) => "type " & _serialize_typename(x),
+            _serialize_typename = (x, optional funtype as logical) =>
+                /* Optional parameter: Is this being used as part of a function signature? */ let
+                    isFunctionType = (x as type) =>
+                        try if Type.FunctionReturn(x) is type then true else false otherwise false,
+                    isTableType = (x as type) =>
+                        try if Type.TableSchema(x) is table then true else false otherwise false,
+                    isRecordType = (x as type) =>
+                        try if Type.ClosedRecord(x) is type then true else false otherwise false,
+                    isListType = (x as type) => try if Type.ListItem(x) is type then true else false otherwise false
+                in
+                    if funtype = null and isTableType(x) then
+                        _serialize_table_type(x)
+                    else if funtype = null and isListType(x) then
+                        "{ " & @_serialize_typename(Type.ListItem(x)) & " }"
+                    else if funtype = null and isFunctionType(x) then
+                        "function " & _serialize_function_type(x)
+                    else if funtype = null and isRecordType(x) then
+                        _serialize_record_type(x)
+                    else if x = type any then
+                        "any"
+                    else
+                        let
+                            base = Type.NonNullable(x)
+                        in
+                            (if Type.IsNullable(x) then "nullable " else "")
+                                & (
+                                    if base = type anynonnull then
+                                        "anynonnull"
+                                    else if base = type binary then
+                                        "binary"
+                                    else if base = type date then
+                                        "date"
+                                    else if base = type datetime then
+                                        "datetime"
+                                    else if base = type datetimezone then
+                                        "datetimezone"
+                                    else if base = type duration then
+                                        "duration"
+                                    else if base = type logical then
+                                        "logical"
+                                    else if base = type none then
+                                        "none"
+                                    else if base = type null then
+                                        "null"
+                                    else if base = type number then
+                                        "number"
+                                    else if base = type text then
+                                        "text"
+                                    else if base = type time then
+                                        "time"
+                                    else if base = type type then
+                                        "type"
+                                    else /* Abstract types: */ if base = type function then
+                                        "function"
+                                    else if base = type table then
+                                        "table"
+                                    else if base = type record then
+                                        "record"
+                                    else if base = type list then
+                                        "list"
+                                    else
+                                        "any /*Actually unknown type*/"
+                                ),
+            _serialize_table_type = (x) =>
+                let
+                    schema = Type.TableSchema(x)
+                in
+                    "table "
+                        & (
+                            if Table.IsEmpty(schema) then
+                                ""
+                            else
+                                "["
+                                    & List.TransformAndCombine(
+                                        Table.ToRecords(Table.Sort(schema, "Position")),
+                                        each Serialize.Identifier(_[Name]) & " = " & _[Kind],
+                                        ", "
+                                    )
+                                    & "] "
+                        ),
+            _serialize_record_type = (x) =>
+                let
+                    flds = Type.RecordFields(x)
+                in
+                    if Record.FieldCount(flds) = 0 then
+                        "record"
+                    else
+                        "["
+                            & List.TransformAndCombine(
+                                Record.FieldNames(flds),
+                                (item) =>
+                                    Serialize.Identifier(item)
+                                        & "="
+                                        & _serialize_typename(Record.Field(flds, item)[Type]),
+                                ", "
+                            )
+                            & (if Type.IsOpenRecord(x) then ", ..." else "")
+                            & "]",
+            _serialize_function_type = (x) =>
+                _serialize_function_param_type(Type.FunctionParameters(x), Type.FunctionRequiredParameters(x))
+                    & " as "
+                    & _serialize_function_return_type(x),
+            _serialize_function_param_type = (t, n) =>
+                let
+                    funsig = Table.ToRecords(
+                        Table.TransformColumns(
+                            Table.AddIndexColumn(Record.ToTable(t), "isOptional", 1), {"isOptional", (x) => x > n}
+                        )
+                    )
+                in
+                    "("
+                        & List.TransformAndCombine(
+                            funsig,
+                            (item) =>
+                                (if item[isOptional] then "optional " else "")
+                                    & Serialize.Identifier(item[Name])
+                                    & " as "
+                                    & _serialize_typename(item[Value], true),
+                            ", "
+                        )
+                        & ")",
+            _serialize_function_return_type = (x) => _serialize_typename(Type.FunctionReturn(x), true),
+            Serialize = (x) as text =>
+                if x is binary then
+                    try Serialize.Binary(x) otherwise "null /*serialize failed*/"
+                else if x is date then
+                    try Expression.Constant(x) otherwise "null /*serialize failed*/"
+                else if x is datetime then
+                    try Expression.Constant(x) otherwise "null /*serialize failed*/"
+                else if x is datetimezone then
+                    try Expression.Constant(x) otherwise "null /*serialize failed*/"
+                else if x is duration then
+                    try Expression.Constant(x) otherwise "null /*serialize failed*/"
+                else if x is function then
+                    try Serialize.Function(x) otherwise "null /*serialize failed*/"
+                else if x is list then
+                    try Serialize.List(x) otherwise "null /*serialize failed*/"
+                else if x is logical then
+                    try Expression.Constant(x) otherwise "null /*serialize failed*/"
+                else if x is null then
+                    try Expression.Constant(x) otherwise "null /*serialize failed*/"
+                else if x is number then
+                    try Expression.Constant(x) otherwise "null /*serialize failed*/"
+                else if x is record then
+                    try Serialize.Record(x) otherwise "null /*serialize failed*/"
+                else if x is table then
+                    try Serialize.Table(x) otherwise "null /*serialize failed*/"
+                else if x is text then
+                    try Expression.Constant(x) otherwise "null /*serialize failed*/"
+                else if x is time then
+                    try Expression.Constant(x) otherwise "null /*serialize failed*/"
+                else if x is type then
+                    try Serialize.Type(x) otherwise "null /*serialize failed*/"
+                else
+                    "[#_unable_to_serialize_#]"
+        in
+            try Serialize(value) otherwise "<serialization failed>"
+in
+    [
+        Fact = Fact,
+        Facts = Facts,
+        SummarizeFacts = Facts.Summarize,
+        ValueToText = ValueToText
+    ]

utilities/Hash.pqm

@@ -0,0 +1,12 @@
+(Value as text) =>
+    let
+        Solution = Binary.ToText(
+            Binary.FromList(
+                Binary.ToList(Binary.Compress(Text.ToBinary(Value, BinaryEncoding.Base64), Compression.GZip))
+            )
+        )
+    in
+        if Value = null then
+            null
+        else
+            Solution

utilities/Table.GenerateByPage.pqm

@@ -0,0 +1,23 @@
+(getNextPage as function) as table =>
+    let
+        listOfPages = List.Generate(
+            () => getNextPage(null),
+            // get the first page of data
+            (lastPage) => lastPage <> null,
+            // stop when the function returns null
+            (lastPage) => getNextPage(lastPage)
+            // pass the previous page to the next function call
+        ),
+        // concatenate the pages together
+        tableOfPages = Table.FromList(listOfPages, Splitter.SplitByNothing(), {"Column1"}),
+        firstRow = tableOfPages{0} ?
+    in
+        // if we didn't get back any pages of data, return an empty table
+        // otherwise set the table type based on the columns of the first page
+        if (firstRow = null) then
+            Table.FromRows({})
+        else
+            Value.ReplaceType(
+                Table.ExpandTableColumn(tableOfPages, "Column1", Table.ColumnNames(firstRow[Column1])),
+                Value.Type(firstRow[Column1])
+            )

utilities/Table.ToNavigationTable.pqm

@@ -0,0 +1,21 @@
+(
+    table as table,
+    keyColumns as list,
+    nameColumn as text,
+    dataColumn as text,
+    itemKindColumn as text,
+    itemNameColumn as text,
+    isLeafColumn as text
+) as table =>
+    let
+        tableType = Value.Type(table),
+        newTableType = Type.AddTableKey(tableType, keyColumns, true) meta [
+            NavigationTable.NameColumn = nameColumn,
+            NavigationTable.DataColumn = dataColumn,
+            NavigationTable.ItemKindColumn = itemKindColumn,
+            Preview.DelayColumn = itemNameColumn,
+            NavigationTable.IsLeafColumn = isLeafColumn
+        ],
+        navigationTable = Value.ReplaceType(table, newTableType)
+    in
+        navigationTable

utilities/Value.WaitFor.pqm

@@ -0,0 +1,14 @@
+(producer as function, interval as function, optional count as number) as any =>
+    let
+        list = List.Generate(
+            () => {0, null},
+            (state) => state{0} <> null and (count = null or state{0} < count),
+            (state) =>
+                if state{1} <> null then
+                    {null, state{1}}
+                else
+                    {1 + state{0}, Function.InvokeAfter(() => producer(state{0}), interval(state{0}))},
+            (state) => state{1}
+        )
+    in
+        List.Last(list)