@taqueria/protocol 0.0.1-test.36 → 0.0.4-test

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@taqueria/protocol",
-  "version": "0.0.1-test.36",
+  "version": "0.0.4-test",
   "description": "A TypeScript package which contains types that are to be shared between @taqueria/node-sdk and @taqueria/taqueria.",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "echo 'Nothing to build.' ",
     "build-ci": "echo \"just passing through for CI, no need to build\" && exit 0",
     "prod-config-ci": "echo \"just passing through for CI, no need to update SDK dependency\" && exit 0"
   },

package/taqueria-protocol-types.ts

@@ -3,6 +3,10 @@
 // or errors emited
 // @ts-ignore
 import {SanitizedAbsPath, SHA256} from '../taqueria-utils/taqueria-utils-types.ts'
+// @ts-ignore
+import {urlParse} from './url-parse.ts'
+
+type URL = ReturnType<typeof urlParse>
 
 /**
  * String-like types
@@ -104,7 +108,7 @@ export class Url {
     }
     static create(value: string): Url | undefined {
         try {
-            const url = new URL(value)
+            const url = urlParse(value)
             return new Url(url)
         }
         catch (_) {
@@ -183,9 +187,14 @@ export interface UnvalidatedNetwork {
     readonly attributes?: Attributes
 }
 
+// NOTE: This is a workaround as TypeScript doesn't support
+// recursive / cyclical types yet. :(
+type Accounts_Base = Record<string, AccountDetails>
+export type Accounts = Record<string, (keyof Accounts_Base)|AccountDetails>
+
 export interface UnvalidatedSandbox extends UnvalidatedNetwork {
     readonly plugin?: string
-    readonly accounts?: Record<string, AccountDetails>
+    readonly accounts?: Accounts 
 }
 
 const hookType: unique symbol = Symbol()
@@ -460,7 +469,7 @@ export interface SandboxConfig {
     readonly rpcUrl?: string
     readonly protocol?: string
     readonly attributes?: Attributes
-    readonly accounts: Record<string|'default', AccountDetails|string>
+    readonly accounts: Accounts
 }
 
 export interface NetworkConfig {
@@ -506,6 +515,7 @@ export class EconomicalProtocolHash extends StringLike {
 
 const economicProtocalType: unique symbol = Symbol()
 export class EconomicalProtocol {
+    [economicProtocalType]: void
     readonly hash: EconomicalProtocolHash
     readonly label: HumanReadableIdentifier | undefined
     constructor(hash: EconomicalProtocolHash, label: (HumanReadableIdentifier|undefined)=undefined) {
@@ -551,11 +561,11 @@ export class Network {
 
 const sandboxType: unique symbol = Symbol()
 export class Sandbox extends Network {
-    readonly accounts: Record<string, AccountDetails>
+    readonly accounts: Accounts
     [sandboxType]: void
     readonly plugin?: string
 
-    protected constructor(name: HumanReadableIdentifier, label: StringMax30, rpcUrl: Url, protocol: EconomicalProtocol, attributes: Attributes, plugin?: string, accounts?: Record<string, AccountDetails>) {
+    protected constructor(name: HumanReadableIdentifier, label: StringMax30, rpcUrl: Url, protocol: EconomicalProtocol, attributes: Attributes, plugin?: string, accounts?: Accounts) {
         super(name, label, rpcUrl, protocol, attributes)
         this.plugin = plugin
         this.accounts = accounts ? accounts: {}

package/url-join.ts

@@ -0,0 +1,73 @@
+export const urlJoin = function (...args: any[]) {
+    let input;
+  
+    if (typeof args[0] === 'object') {
+      input = args[0];
+    } else {
+      input = [].slice.call(args);
+    }
+  
+    return normalize(input);
+  };
+  
+  const normalize = (strArray: Array<string>) => {
+    const resultArray = [];
+    if (strArray.length === 0) {
+      return '';
+    }
+  
+    if (typeof strArray[0] !== 'string') {
+      throw new TypeError('Url must be a string. Received ' + strArray[0]);
+    }
+  
+    // If the first part is a plain protocol, we combine it with the next part.
+    if (strArray[0].match(/^[^/:]+:\/*$/) && strArray.length > 1) {
+      const first = strArray.shift();
+      strArray[0] = first + strArray[0];
+    }
+  
+    // There must be two or three slashes in the file protocol, two slashes in anything else.
+    if (strArray[0].match(/^file:\/\/\//)) {
+      strArray[0] = strArray[0].replace(/^([^/:]+):\/*/, '$1:///');
+    } else {
+      strArray[0] = strArray[0].replace(/^([^/:]+):\/*/, '$1://');
+    }
+  
+    for (let i = 0; i < strArray.length; i++) {
+      let component = strArray[i];
+  
+      if (typeof component !== 'string') {
+        throw new TypeError('Url must be a string. Received ' + component);
+      }
+  
+      if (component === '') {
+        continue;
+      }
+  
+      if (i > 0) {
+        // Removing the starting slashes for each component but the first.
+        component = component.replace(/^[\/]+/, '');
+      }
+      if (i < strArray.length - 1) {
+        // Removing the ending slashes for each component but the last.
+        component = component.replace(/[\/]+$/, '');
+      } else {
+        // For the last component we will combine multiple slashes to a single one.
+        component = component.replace(/[\/]+$/, '/');
+      }
+  
+      resultArray.push(component);
+    }
+  
+    let str = resultArray.join('/');
+    // Each input component is now separated by a single slash except the possible first plain protocol part.
+  
+    // remove trailing slash before parameters or hash
+    str = str.replace(/\/(\?|&|#[^!])/g, '$1');
+  
+    // replace ? in parameters with &
+    let parts = str.split('?');
+    str = parts.shift() + (parts.length > 0 ? '?' : '') + parts.join('&');
+  
+    return str;
+  };

package/url-parse.ts

@@ -0,0 +1,150 @@
+// @ts-ignore
+import { urlJoin } from "./url-join.ts"
+
+export interface IUrlParams {
+  key: string;
+  value: string;
+}
+
+export interface IUrlParse {
+  protocol?: string;
+  hostname?: string;
+  pathname?: Array<string> | string;
+  port?: string | number;
+  username?: string;
+  password?: string;
+  query?: Array<IUrlParams> | null;
+}
+
+export interface IUrl {
+  href: string;
+  origin: string;
+  host: string;
+  protocol: string;
+  username: string;
+  password: string;
+  hostname: string;
+  port: string;
+  pathname: string;
+  hash: string;
+  search: string;
+  toString: () => string;
+}
+
+export const urlParse = (
+  data: IUrlParse | string | null | undefined = {}
+): IUrl => {
+  let url = new URL("http://localhost");
+  let innerData: IUrlParse = {};
+
+  if (typeof data === "string") {
+    url = new URL(data);
+
+    if (url.protocol) {
+      innerData.protocol = url.protocol;
+    }
+    if (url.hostname) {
+      innerData.hostname = url.hostname;
+    }
+    if (url.port) {
+      innerData.port = url.port;
+    }
+    if (url.username) {
+      innerData.username = url.username;
+    }
+    if (url.password) {
+      innerData.password = url.password;
+    }
+    if (url.searchParams) {
+      url.searchParams.forEach((value, key) => {
+        innerData?.query?.push({ value, key });
+      });
+    }
+  } else {
+    if (!data) {
+      // if null or undefined
+      innerData = {};
+    } else {
+      // if data exists
+      innerData = data;
+    }
+  }
+
+  const {
+    protocol = "http",
+    hostname,
+    pathname,
+    port,
+    username,
+    password,
+    query = null,
+  } = innerData;
+
+  if (!protocol || !hostname) {
+    throw new Error("You should at least set the protocol and the hostname");
+  }
+
+  if (protocol) {
+    url.protocol = protocol;
+  }
+
+  if (hostname) {
+    url.hostname = hostname;
+  }
+
+  if (pathname) {
+    if (Array.isArray(pathname)) {
+      url.pathname = urlJoin(...pathname);
+    } else {
+      url.pathname = pathname;
+    }
+  }
+
+  if (typeof port === "number") {
+    url.port = String(port).toString();
+  } else {
+    if (port) {
+      url.port = port;
+    }
+  }
+  if (username) {
+    url.username = username;
+  }
+  if (password) {
+    url.password = password;
+  }
+  if (query && Array.isArray(query)) {
+    query.forEach(({ key, value }) => {
+      url.searchParams.append(key, value);
+    });
+  }
+
+  const result: IUrl = {
+    href: url.href,
+    origin: url.origin,
+    protocol: url.protocol,
+    username: url.username,
+    password: url.password,
+    host: url.host,
+    hostname: url.hostname,
+    port: url.port,
+    pathname: url.pathname,
+    hash: url.hash,
+    search: url.search,
+    toString() {
+      return this.href;
+    },
+  };
+
+  if (protocol) {
+    const toUseProtocol = protocol.trim().endsWith(":")
+      ? protocol.trim()
+      : `${protocol.trim()}:`;
+
+    result.href = result.href.replace(result.protocol, toUseProtocol);
+    result.origin = result.origin.replace(result.protocol, toUseProtocol);
+    result.protocol = toUseProtocol;
+  }
+
+  return result;
+};