1.0.107

.gitea/workflows/default_nottags.yaml

@@ -0,0 +1,66 @@
+name: Default (not tags)
+
+on:
+  push:
+    tags-ignore:
+      - '**'
+
+env:
+  IMAGE: registry.gitlab.com/hosttoday/ht-docker-node:npmci
+  NPMCI_COMPUTED_REPOURL: https://${{gitea.repository_owner}}:${{secrets.GITEA_TOKEN}}@gitea.lossless.digital/${{gitea.repository}}.git
+  NPMCI_TOKEN_NPM: ${{secrets.NPMCI_TOKEN_NPM}}
+  NPMCI_TOKEN_NPM2: ${{secrets.NPMCI_TOKEN_NPM2}}
+  NPMCI_GIT_GITHUBTOKEN: ${{secrets.NPMCI_GIT_GITHUBTOKEN}}
+  NPMCI_URL_CLOUDLY: ${{secrets.NPMCI_URL_CLOUDLY}}
+
+jobs:
+  security:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Install pnpm and npmci
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+
+      - name: Run npm prepare
+        run: npmci npm prepare
+
+      - name: Audit production dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --prod
+        continue-on-error: true
+
+      - name: Audit development dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --dev
+        continue-on-error: true
+
+  test:
+    if: ${{ always() }}
+    needs: security
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Test stable
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm test
+
+      - name: Test build
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm build

.gitea/workflows/default_tags.yaml

@@ -0,0 +1,124 @@
+name: Default (tags)
+
+on:
+  push:
+    tags:
+      - '*'
+
+env:
+  IMAGE: registry.gitlab.com/hosttoday/ht-docker-node:npmci
+  NPMCI_COMPUTED_REPOURL: https://${{gitea.repository_owner}}:${{secrets.GITEA_TOKEN}}@gitea.lossless.digital/${{gitea.repository}}.git
+  NPMCI_TOKEN_NPM: ${{secrets.NPMCI_TOKEN_NPM}}
+  NPMCI_TOKEN_NPM2: ${{secrets.NPMCI_TOKEN_NPM2}}
+  NPMCI_GIT_GITHUBTOKEN: ${{secrets.NPMCI_GIT_GITHUBTOKEN}}
+  NPMCI_URL_CLOUDLY: ${{secrets.NPMCI_URL_CLOUDLY}}
+
+jobs:
+  security:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+          npmci npm prepare
+
+      - name: Audit production dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --prod
+        continue-on-error: true
+
+      - name: Audit development dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --dev
+        continue-on-error: true
+
+  test:
+    if: ${{ always() }}
+    needs: security
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+          npmci npm prepare
+
+      - name: Test stable
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm test
+
+      - name: Test build
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm build
+
+  release:
+    needs: test
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+          npmci npm prepare
+
+      - name: Release
+        run: |
+          npmci node install stable
+          npmci npm publish
+
+  metadata:
+    needs: test
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+    continue-on-error: true
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+          npmci npm prepare
+
+      - name: Code quality
+        run: |
+          npmci command npm install -g typescript
+          npmci npm install
+
+      - name: Trigger
+        run: npmci trigger
+
+      - name: Build docs and upload artifacts
+        run: |
+          npmci node install stable
+          npmci npm install
+          pnpm install -g @git.zone/tsdoc
+          npmci command tsdoc
+        continue-on-error: true

.gitignore

@@ -15,8 +15,6 @@ node_modules/
 
 # builds
 dist/
-dist_web/
-dist_serve/
-dist_ts_web/
+dist_*/
 
 # custom

.gitlab-ci.yml

@@ -1,121 +0,0 @@
-# gitzone ci_default
-image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
-
-cache:
-  paths:
-  - .npmci_cache/
-  key: "$CI_BUILD_STAGE"
-
-stages:
-- security
-- test
-- release
-- metadata
-
-# ====================
-# security stage
-# ====================
-mirror:
-  stage: security
-  script:
-  - npmci git mirror
-  tags:
-  - docker
-  - notpriv
-
-snyk:
-  stage: security
-  script:
-    - npmci npm prepare
-    - npmci command npm install -g snyk
-    - npmci command npm install --ignore-scripts
-    - npmci command snyk test
-  tags:
-  - docker
-  - notpriv
-
-# ====================
-# test stage
-# ====================
-
-testLTS:
-  services:
-    - docker:18-dind
-  stage: test
-  script:
-  - npmci npm prepare
-  - npmci node install lts
-  - npmci npm install
-  - npmci npm test
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-  - docker
-  - priv
-
-testBuild:
-  stage: test
-  script:
-  - npmci npm prepare
-  - npmci node install lts
-  - npmci npm install
-  - npmci command npm run build
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-  - docker
-  - notpriv
-
-release:
-  stage: release
-  script:
-  - npmci node install lts
-  - npmci npm publish
-  only:
-  - tags
-  tags:
-  - docker
-  - notpriv
-
-# ====================
-# metadata stage
-# ====================
-codequality:
-  stage: metadata
-  allow_failure: true
-  script:
-    - npmci command npm install -g tslint typescript
-    - npmci npm install
-    - npmci command "tslint -c tslint.json ./ts/**/*.ts"
-  tags:
-  - docker
-  - priv
-
-trigger:
-  stage: metadata
-  script:
-  - npmci trigger
-  only:
-  - tags
-  tags:
-  - docker
-  - notpriv
-
-pages:
-  image: hosttoday/ht-docker-dbase:npmci
-  services:
-   - docker:18-dind
-  stage: metadata
-  script:
-    - npmci command npm install -g @gitzone/tsdoc
-    - npmci npm prepare
-    - npmci npm install
-    - npmci command tsdoc
-  tags:
-    - docker
-    - notpriv
-  only:
-    - tags
-  artifacts:
-    expire_in: 1 week
-    paths:
-    - public
-  allow_failure: true

.vscode/launch.json

@@ -2,28 +2,10 @@
   "version": "0.2.0",
   "configurations": [
     {
-      "name": "current file",
-      "type": "node",
+      "command": "npm test",
+      "name": "Run npm test",
       "request": "launch",
-      "args": [
-        "${relativeFile}"
-      ],
-      "runtimeArgs": ["-r", "@gitzone/tsrun"],
-      "cwd": "${workspaceRoot}",
-      "protocol": "inspector",
-      "internalConsoleOptions": "openOnSessionStart"
-    },
-    {
-      "name": "test.ts",
-      "type": "node",
-      "request": "launch",
-      "args": [
-        "test/test.ts"
-      ],
-      "runtimeArgs": ["-r", "@gitzone/tsrun"],
-      "cwd": "${workspaceRoot}",
-      "protocol": "inspector",
-      "internalConsoleOptions": "openOnSessionStart"
+      "type": "node-terminal"
     }
   ]
 }

.vscode/settings.json

@@ -0,0 +1,26 @@
+{
+  "json.schemas": [
+    {
+      "fileMatch": ["/npmextra.json"],
+      "schema": {
+        "type": "object",
+        "properties": {
+          "npmci": {
+            "type": "object",
+            "description": "settings for npmci"
+          },
+          "gitzone": {
+            "type": "object",
+            "description": "settings for gitzone",
+            "properties": {
+              "projectType": {
+                "type": "string",
+                "enum": ["website", "element", "service", "npm", "wcc"]
+              }
+            }
+          }
+        }
+      }
+    }
+  ]
+}

README.md

@@ -1,38 +0,0 @@
-# @mojoio/docker
-unofficial docker engine api abstraction package written in TypeScript
-
-## Availabililty and Links
-* [npmjs.org (npm package)](https://www.npmjs.com/package/@mojoio/docker)
-* [gitlab.com (source)](https://gitlab.com/mojoio/docker)
-* [github.com (source mirror)](https://github.com/mojoio/docker)
-* [docs (typedoc)](https://mojoio.gitlab.io/docker/)
-
-## Status for master
-[![build status](https://gitlab.com/mojoio/docker/badges/master/build.svg)](https://gitlab.com/mojoio/docker/commits/master)
-[![coverage report](https://gitlab.com/mojoio/docker/badges/master/coverage.svg)](https://gitlab.com/mojoio/docker/commits/master)
-[![npm downloads per month](https://img.shields.io/npm/dm/@mojoio/docker.svg)](https://www.npmjs.com/package/@mojoio/docker)
-[![Known Vulnerabilities](https://snyk.io/test/npm/@mojoio/docker/badge.svg)](https://snyk.io/test/npm/@mojoio/docker)
-[![TypeScript](https://img.shields.io/badge/TypeScript->=%203.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
-[![node](https://img.shields.io/badge/node->=%2010.x.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
-[![JavaScript Style Guide](https://img.shields.io/badge/code%20style-prettier-ff69b4.svg)](https://prettier.io/)
-
-## Usage
-
-Use TypeScript for best in class instellisense.
-
-```typescript
-import { DockerHost } from '@mojoio/docker'; // require Dockersock class
-
-const run = async () => {
-  const myDockerHost = new DockerHost(); // optional: you can pass a domain to the contructor, defaults to  /var/run/docker.sock
-
-  const containers = await myDockerHost.getContainers(); // promise, resolve with an array of DockerContainers
-};
-```
-
-For further information read the linked docs at the top of this readme.
-
-> MIT licensed | **©** [Lossless GmbH](https://lossless.gmbh)
-| By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy)
-
-[![repo-footer](https://lossless.gitlab.io/publicrelations/repofooter.svg)](https://maintainedby.lossless.com)

npmextra.json

@@ -10,11 +10,12 @@
     "npmRegistryUrl": "registry.npmjs.org"
   },
   "gitzone": {
+    "projectType": "npm",
     "module": {
       "githost": "gitlab.com",
       "gitscope": "mojoio",
       "gitrepo": "docker",
-      "shortDescription": "unofficial docker engine api abstraction package written in TypeScript",
+      "description": "unofficial docker engine api abstraction package written in TypeScript",
       "npmPackagename": "@mojoio/docker",
       "license": "MIT"
     }

package.json

@@ -1,17 +1,19 @@
 {
-  "name": "@mojoio/docker",
-  "version": "1.0.62",
+  "name": "@apiclient.xyz/docker",
+  "version": "1.0.107",
   "description": "easy communication with docker remote api from node, TypeScript ready",
   "private": false,
-  "main": "dist/index.js",
-  "typings": "dist/index.d.ts",
+  "main": "dist_ts/index.js",
+  "typings": "dist_ts/index.d.ts",
+  "type": "module",
   "scripts": {
-    "test": "tstest test/",
-    "build": "tsbuild"
+    "test": "(tstest test/ --web)",
+    "build": "(tsbuild --web --allowimplicitany)",
+    "buildDocs": "tsdoc"
   },
   "repository": {
     "type": "git",
-    "url": "git+ssh://git@gitlab.com/pushrocks/dockersock.git"
+    "url": "git+https://gitlab.com/mojoio/docker.git"
   },
   "keywords": [
     "docker",
@@ -23,40 +25,43 @@
   "author": "Lossless GmbH",
   "license": "MIT",
   "bugs": {
-    "url": "https://gitlab.com/pushrocks/dockersock/issues"
+    "url": "https://gitlab.com/mojoio/docker/issues"
   },
-  "homepage": "https://gitlab.com/pushrocks/dockersock#README",
+  "homepage": "https://gitlab.com/mojoio/docker#readme",
   "dependencies": {
-    "@pushrocks/lik": "^3.0.11",
-    "@pushrocks/smartfile": "^7.0.4",
-    "@pushrocks/smartjson": "^3.0.8",
-    "@pushrocks/smartlog": "^2.0.19",
-    "@pushrocks/smartnetwork": "^1.1.14",
-    "@pushrocks/smartpath": "^4.0.1",
-    "@pushrocks/smartpromise": "^3.0.2",
-    "@pushrocks/smartrequest": "^1.1.26",
-    "@pushrocks/smartstring": "^3.0.10",
-    "@pushrocks/smartversion": "^2.0.4",
-    "rxjs": "^6.5.3"
+    "@push.rocks/lik": "^6.0.0",
+    "@push.rocks/smartfile": "^11.0.4",
+    "@push.rocks/smartjson": "^5.0.2",
+    "@push.rocks/smartlog": "^3.0.1",
+    "@push.rocks/smartnetwork": "^3.0.0",
+    "@push.rocks/smartpath": "^5.0.5",
+    "@push.rocks/smartpromise": "^4.0.3",
+    "@push.rocks/smartrequest": "^2.0.11",
+    "@push.rocks/smartstring": "^4.0.5",
+    "@push.rocks/smartversion": "^3.0.2",
+    "@tsclass/tsclass": "^4.0.24",
+    "rxjs": "^7.5.7"
   },
   "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.17",
-    "@gitzone/tsrun": "^1.2.8",
-    "@gitzone/tstest": "^1.0.24",
-    "@pushrocks/tapbundle": "^3.0.13",
-    "@types/node": "^12.7.4",
-    "tslint": "^5.19.0",
-    "tslint-config-prettier": "^1.18.0"
+    "@git.zone/tsbuild": "^2.1.25",
+    "@git.zone/tsrun": "^1.2.12",
+    "@git.zone/tstest": "^1.0.52",
+    "@push.rocks/tapbundle": "^5.0.4",
+    "@types/node": "^20.11.16"
   },
   "files": [
-    "ts/*",
-    "ts_web/*",
-    "dist/*",
-    "dist_web/*",
-    "dist_ts_web/*",
-    "assets/*",
+    "ts/**/*",
+    "ts_web/**/*",
+    "dist/**/*",
+    "dist_*/**/*",
+    "dist_ts/**/*",
+    "dist_ts_web/**/*",
+    "assets/**/*",
     "cli.js",
     "npmextra.json",
     "readme.md"
+  ],
+  "browserslist": [
+    "last 1 chrome versions"
   ]
 }

readme.md

@@ -0,0 +1,49 @@
+# @mojoio/docker
+unofficial docker engine api abstraction package written in TypeScript
+
+## Availabililty and Links
+* [npmjs.org (npm package)](https://www.npmjs.com/package/@mojoio/docker)
+* [gitlab.com (source)](https://gitlab.com/mojoio/docker)
+* [github.com (source mirror)](https://github.com/mojoio/docker)
+* [docs (typedoc)](https://mojoio.gitlab.io/docker/)
+
+## Status for master
+
+Status Category | Status Badge
+-- | --
+GitLab Pipelines | [![pipeline status](https://gitlab.com/mojoio/docker/badges/master/pipeline.svg)](https://lossless.cloud)
+GitLab Pipline Test Coverage | [![coverage report](https://gitlab.com/mojoio/docker/badges/master/coverage.svg)](https://lossless.cloud)
+npm | [![npm downloads per month](https://badgen.net/npm/dy/@mojoio/docker)](https://lossless.cloud)
+Snyk | [![Known Vulnerabilities](https://badgen.net/snyk/mojoio/docker)](https://lossless.cloud)
+TypeScript Support | [![TypeScript](https://badgen.net/badge/TypeScript/>=%203.x/blue?icon=typescript)](https://lossless.cloud)
+node Support | [![node](https://img.shields.io/badge/node->=%2010.x.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
+Code Style | [![Code Style](https://badgen.net/badge/style/prettier/purple)](https://lossless.cloud)
+PackagePhobia (total standalone install weight) | [![PackagePhobia](https://badgen.net/packagephobia/install/@mojoio/docker)](https://lossless.cloud)
+PackagePhobia (package size on registry) | [![PackagePhobia](https://badgen.net/packagephobia/publish/@mojoio/docker)](https://lossless.cloud)
+BundlePhobia (total size when bundled) | [![BundlePhobia](https://badgen.net/bundlephobia/minzip/@mojoio/docker)](https://lossless.cloud)
+Platform support | [![Supports Windows 10](https://badgen.net/badge/supports%20Windows%2010/yes/green?icon=windows)](https://lossless.cloud) [![Supports Mac OS X](https://badgen.net/badge/supports%20Mac%20OS%20X/yes/green?icon=apple)](https://lossless.cloud)
+
+## Usage
+
+Use TypeScript for best in class instellisense.
+
+```typescript
+import { DockerHost } from '@mojoio/docker'; // require Dockersock class
+
+const run = async () => {
+  const myDockerHost = new DockerHost(); // optional: you can pass a domain to the contructor, defaults to  /var/run/docker.sock
+
+  const containers = await myDockerHost.getContainers(); // promise, resolve with an array of DockerContainers
+};
+```
+
+## Contribution
+
+We are always happy for code contributions. If you are not the code contributing type that is ok. Still, maintaining Open Source repositories takes considerable time and thought. If you like the quality of what we do and our modules are useful to you we would appreciate a little monthly contribution: You can [contribute one time](https://lossless.link/contribute-onetime) or [contribute monthly](https://lossless.link/contribute). :)
+
+For further information read the linked docs at the top of this readme.
+
+> MIT licensed | **©** [Lossless GmbH](https://lossless.gmbh)
+| By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy)
+
+[![repo-footer](https://lossless.gitlab.io/publicrelations/repofooter.svg)](https://maintainedby.lossless.com)

scripts/testauth.ts

@@ -0,0 +1,11 @@
+import * as docker from '../ts';
+import * as smartstring from '@push.rocks/smartstring';
+
+const run  = async () => {
+  const dockerHost = new docker.DockerHost();
+  await docker.DockerImage.createFromRegistry(dockerHost, {
+    imageUrl: 'registry.gitlab.com/servezone/private/cloudly:latest'
+  });
+};
+
+run();

test/test.nonci.node.ts

@@ -1,11 +1,11 @@
-import { expect, tap } from '@pushrocks/tapbundle';
-import * as docker from '../ts/index';
+import { expect, tap } from '@push.rocks/tapbundle';
+import * as docker from '../ts/index.js';
 
 let testDockerHost: docker.DockerHost;
 
 tap.test('should create a new Dockersock instance', async () => {
-  testDockerHost = new docker.DockerHost('http://unix:/var/run/docker.sock:');
-  return expect(testDockerHost).to.be.instanceof(docker.DockerHost);
+  testDockerHost = new docker.DockerHost();
+  return expect(testDockerHost).toBeInstanceOf(docker.DockerHost);
 });
 
 tap.test('should create a docker swarm', async () => {
@@ -26,10 +26,10 @@ tap.test('should list networks', async () => {
 
 tap.test('should create a network', async () => {
   const newNetwork = await docker.DockerNetwork.createNetwork(testDockerHost, {
-    Name: 'webgateway'
+    Name: 'webgateway',
   });
-  expect(newNetwork).to.be.instanceOf(docker.DockerNetwork);
-  expect(newNetwork.Name).to.equal('webgateway');
+  expect(newNetwork).toBeInstanceOf(docker.DockerNetwork);
+  expect(newNetwork.Name).toEqual('webgateway');
 });
 
 tap.test('should remove a network', async () => {
@@ -41,15 +41,15 @@ tap.test('should remove a network', async () => {
 tap.test('should pull an image from imagetag', async () => {
   const image = await docker.DockerImage.createFromRegistry(testDockerHost, {
     imageUrl: 'hosttoday/ht-docker-node',
-    imageTag: 'alpine'
+    imageTag: 'alpine',
   });
-  expect(image).to.be.instanceOf(docker.DockerImage);
+  expect(image).toBeInstanceOf(docker.DockerImage);
   console.log(image);
 });
 
-tap.test('should return a change Observable', async tools => {
+tap.test('should return a change Observable', async (tools) => {
   const testObservable = await testDockerHost.getEventObservable();
-  const subscription = testObservable.subscribe(changeObject => {
+  const subscription = testObservable.subscribe((changeObject) => {
     console.log(changeObject);
   });
   await tools.delayFor(2000);
@@ -62,7 +62,7 @@ tap.test('should create a secret', async () => {
     name: 'testSecret',
     version: '1.0.3',
     contentArg: `{ "hi": "wow"}`,
-    labels: {}
+    labels: {},
   });
   console.log(mySecret);
 });
@@ -72,44 +72,39 @@ tap.test('should remove a secret by name', async () => {
   await mySecret.remove();
 });
 
-
 // SERVICES
 tap.test('should activate swarm mode', async () => {
   await testDockerHost.activateSwarm();
 });
 
-tap.test('should list all services', async tools => {
+tap.test('should list all services', async (tools) => {
   const services = await testDockerHost.getServices();
   console.log(services);
 });
 
 tap.test('should create a service', async () => {
   const testNetwork = await docker.DockerNetwork.createNetwork(testDockerHost, {
-    Name: 'testNetwork'
+    Name: 'testNetwork',
   });
   const testSecret = await docker.DockerSecret.createSecret(testDockerHost, {
-    name: 'serviceSecret',
+    name: 'testSecret',
     version: '0.0.1',
     labels: {},
-    contentArg: '{"hi": "wow"}'
+    contentArg: '{"hi": "wow"}',
   });
   const testImage = await docker.DockerImage.createFromRegistry(testDockerHost, {
-    imageUrl: 'nginx:latest'
+    imageUrl: 'registry.gitlab.com/hosttoday/ht-docker-static',
   });
   const testService = await docker.DockerService.createService(testDockerHost, {
     image: testImage,
-    labels: {    
-      'testlabel': 'hi'
-    },
+    labels: {},
     name: 'testService',
     networks: [testNetwork],
     networkAlias: 'testService',
-    secrets: [testSecret]
+    secrets: [testSecret],
+    ports: ['3000:80'],
   });
 
-  await testSecret.update(`{"updated": "socool"}`);
-  await testService.update();
-
   await testService.remove();
   await testNetwork.remove();
   await testSecret.remove();

ts/00_commitinfo_data.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@apiclient.xyz/docker',
+  version: '1.0.107',
+  description: 'easy communication with docker remote api from node, TypeScript ready'
+}

ts/docker.classes.container.ts

@@ -1,7 +1,8 @@
-import * as plugins from './docker.plugins';
-import * as interfaces from './interfaces';
+import * as plugins from './docker.plugins.js';
+import * as interfaces from './interfaces/index.js';
 
-import { DockerHost } from './docker.classes.host';
+import { DockerHost } from './docker.classes.host.js';
+import { logger } from './docker.logging.js';
 
 export class DockerContainer {
   // STATIC
@@ -37,22 +38,19 @@ export class DockerContainer {
   ) {
     // check for unique hostname
     const existingContainers = await DockerContainer.getContainers(dockerHost);
-    const sameHostNameContainer = existingContainers.find(container => {
+    const sameHostNameContainer = existingContainers.find((container) => {
       // TODO implement HostName Detection;
       return false;
     });
     const response = await dockerHost.request('POST', '/containers/create', {
       Hostname: containerCreationDescriptor.Hostname,
       Domainname: containerCreationDescriptor.Domainname,
-      User: 'root'
+      User: 'root',
     });
     if (response.statusCode < 300) {
-      plugins.smartlog.defaultLogger.log('info', 'Container created successfully');
+      logger.log('info', 'Container created successfully');
     } else {
-      plugins.smartlog.defaultLogger.log(
-        'error',
-        'There has been a problem when creating the container'
-      );
+      logger.log('error', 'There has been a problem when creating the container');
     }
   }
 
@@ -94,7 +92,7 @@ export class DockerContainer {
   public Mounts: any;
   constructor(dockerHostArg: DockerHost, dockerContainerObjectArg: any) {
     this.dockerHost = dockerHostArg;
-    Object.keys(dockerContainerObjectArg).forEach(keyArg => {
+    Object.keys(dockerContainerObjectArg).forEach((keyArg) => {
       this[keyArg] = dockerContainerObjectArg[keyArg];
     });
   }

ts/docker.classes.host.ts

@@ -1,7 +1,15 @@
-import * as plugins from './docker.plugins';
-import { DockerContainer } from './docker.classes.container';
-import { DockerNetwork } from './docker.classes.network';
-import { DockerService } from './docker.classes.service';
+import * as plugins from './docker.plugins.js';
+import { DockerContainer } from './docker.classes.container.js';
+import { DockerNetwork } from './docker.classes.network.js';
+import { DockerService } from './docker.classes.service.js';
+import { logger } from './docker.logging.js';
+import path from 'path';
+
+export interface IAuthData {
+  serveraddress: string;
+  username: string;
+  password: string;
+}
 
 export class DockerHost {
   /**
@@ -18,11 +26,17 @@ export class DockerHost {
     let pathToUse: string;
     if (pathArg) {
       pathToUse = pathArg;
+    } else if (process.env.DOCKER_HOST) {
+      pathToUse = process.env.DOCKER_HOST;
     } else if (process.env.CI) {
       pathToUse = 'http://docker:2375/';
     } else {
       pathToUse = 'http://unix:/var/run/docker.sock:';
     }
+    if (pathToUse.startsWith('unix:///')) {
+      pathToUse = pathToUse.replace('unix://', 'http://unix:') + ':';
+    }
+    console.log(`using docker sock at ${pathToUse}`);
     this.socketPath = pathToUse;
   }
 
@@ -31,35 +45,30 @@ export class DockerHost {
    * @param userArg
    * @param passArg
    */
-  public async auth(registryUrl: string, userArg: string, passArg: string) {
-    const response = await this.request('POST', '/auth', {
-      serveraddress: registryUrl,
-      username: userArg,
-      password: passArg
-    });
+  public async auth(authData: IAuthData) {
+    const response = await this.request('POST', '/auth', authData);
     if (response.body.Status !== 'Login Succeeded') {
       console.log(`Login failed with ${response.body.Status}`);
       throw new Error(response.body.Status);
     }
     console.log(response.body.Status);
-    this.registryToken = plugins.smartstring.base64.encode(response.body.IdentityToken);
-  }
-
-  /**
-   * sets an auth token
-   * @param authToken 
-   */
-  public setAuthToken(authToken: string) {
-    this.registryToken = authToken;
+    this.registryToken = plugins.smartstring.base64.encode(plugins.smartjson.stringify(authData));
   }
 
   /**
    * gets the token from the .docker/config.json file for GitLab registry
    */
-  public getGitlabComTokenFromDockerConfig() {
+  public async getGitlabComTokenFromDockerConfig() {
     const dockerConfigPath = plugins.smartpath.get.home('~/.docker/config.json');
     const configObject = plugins.smartfile.fs.toObjectSync(dockerConfigPath);
-    this.registryToken = configObject.auths['registry.gitlab.com'].auth;
+    const gitlabAuthBase64 = configObject.auths['registry.gitlab.com'].auth;
+    const gitlabAuth: string = plugins.smartstring.base64.decode(gitlabAuthBase64);
+    const gitlabAuthArray = gitlabAuth.split(':');
+    await this.auth({
+      username: gitlabAuthArray[0],
+      password: gitlabAuthArray[1],
+      serveraddress: 'registry.gitlab.com',
+    });
   }
 
   /**
@@ -70,10 +79,9 @@ export class DockerHost {
   }
 
   /**
-   * 
+   *
    */
 
-
   /**
    * gets all containers
    */
@@ -95,8 +103,8 @@ export class DockerHost {
    */
   public async getEventObservable(): Promise<plugins.rxjs.Observable<any>> {
     const response = await this.requestStreaming('GET', '/events');
-    return plugins.rxjs.Observable.create(observer => {
-      response.on('data', data => {
+    return plugins.rxjs.Observable.create((observer) => {
+      response.on('data', (data) => {
         const eventString = data.toString();
         try {
           const eventObject = JSON.parse(eventString);
@@ -133,12 +141,12 @@ export class DockerHost {
       DataPathPort: 4789,
       DefaultAddrPool: ['10.10.0.0/8', '20.20.0.0/8'],
       SubnetSize: 24,
-      ForceNewCluster: false
+      ForceNewCluster: false,
     });
     if (response.statusCode === 200) {
-      plugins.smartlog.defaultLogger.log('info', 'created Swam succesfully');
+      logger.log('info', 'created Swam succesfully');
     } else {
-      plugins.smartlog.defaultLogger.log('error', 'could not initiate swarm');
+      logger.log('error', 'could not initiate swarm');
     }
   }
 
@@ -152,10 +160,10 @@ export class DockerHost {
       headers: {
         'Content-Type': 'application/json',
         'X-Registry-Auth': this.registryToken,
-        Host: 'docker.sock'
+        Host: 'docker.sock',
       },
       requestBody: dataArg,
-      keepAlive: false
+      keepAlive: false,
     });
     if (response.statusCode !== 200) {
       console.log(response.body);
@@ -171,10 +179,11 @@ export class DockerHost {
         method: methodArg,
         headers: {
           'Content-Type': 'application/json',
-          Host: 'docker.sock'
+          'X-Registry-Auth': this.registryToken,
+          Host: 'docker.sock',
         },
         requestBody: null,
-        keepAlive: false
+        keepAlive: false,
       },
       true
     );

ts/docker.classes.image.ts

@@ -1,6 +1,7 @@
-import * as plugins from './docker.plugins';
-import * as interfaces from './interfaces';
-import { DockerHost } from './docker.classes.host';
+import * as plugins from './docker.plugins.js';
+import * as interfaces from './interfaces/index.js';
+import { DockerHost } from './docker.classes.host.js';
+import { logger } from './docker.logging.js';
 
 export class DockerImage {
   // STATIC
@@ -15,13 +16,12 @@ export class DockerImage {
 
   public static async findImageByName(dockerHost: DockerHost, imageNameArg: string) {
     const images = await this.getImages(dockerHost);
-    const result = images.find(image => {
+    const result = images.find((image) => {
       if (image.RepoTags) {
         return image.RepoTags.includes(imageNameArg);
       } else {
         return false;
       }
-      
     });
     return result;
   }
@@ -30,7 +30,6 @@ export class DockerImage {
     dockerHostArg: DockerHost,
     creationObject: interfaces.IImageCreationDescriptor
   ): Promise<DockerImage> {
-
     // lets create a sanatized imageUrlObject
     const imageUrlObject: {
       imageUrl: string;
@@ -39,16 +38,14 @@ export class DockerImage {
     } = {
       imageUrl: creationObject.imageUrl,
       imageTag: creationObject.imageTag,
-      imageOriginTag: null
+      imageOriginTag: null,
     };
     if (imageUrlObject.imageUrl.includes(':')) {
       const imageUrl = imageUrlObject.imageUrl.split(':')[0];
       const imageTag = imageUrlObject.imageUrl.split(':')[1];
       if (imageUrlObject.imageTag) {
         throw new Error(
-          `imageUrl ${imageUrlObject.imageUrl} can't be tagged with ${
-            imageUrlObject.imageTag
-          } because it is already tagged with ${imageTag}`
+          `imageUrl ${imageUrlObject.imageUrl} can't be tagged with ${imageUrlObject.imageTag} because it is already tagged with ${imageTag}`
         );
       } else {
         imageUrlObject.imageUrl = imageUrl;
@@ -67,14 +64,11 @@ export class DockerImage {
       )}&tag=${encodeURIComponent(imageUrlObject.imageTag)}`
     );
     if (response.statusCode < 300) {
-      plugins.smartlog.defaultLogger.log(
-        'info',
-        `Successfully pulled image ${imageUrlObject.imageUrl} from the registry`
-      );
+      logger.log('info', `Successfully pulled image ${imageUrlObject.imageUrl} from the registry`);
       const image = await DockerImage.findImageByName(dockerHostArg, imageUrlObject.imageOriginTag);
       return image;
     } else {
-      plugins.smartlog.defaultLogger.log('error', `Failed at the attempt of creating a new image`);
+      logger.log('error', `Failed at the attempt of creating a new image`);
     }
   }
 
@@ -114,7 +108,7 @@ export class DockerImage {
 
   constructor(dockerHostArg, dockerImageObjectArg: any) {
     this.dockerHost = dockerHostArg;
-    Object.keys(dockerImageObjectArg).forEach(keyArg => {
+    Object.keys(dockerImageObjectArg).forEach((keyArg) => {
       this[keyArg] = dockerImageObjectArg[keyArg];
     });
   }
@@ -132,7 +126,7 @@ export class DockerImage {
    */
   public async pullLatestImageFromRegistry(): Promise<boolean> {
     const updatedImage = await DockerImage.createFromRegistry(this.dockerHost, {
-      imageUrl: this.RepoTags[0]
+      imageUrl: this.RepoTags[0],
     });
     Object.assign(this, updatedImage);
     // TODO: Compare image digists before and after
@@ -141,6 +135,10 @@ export class DockerImage {
 
   // get stuff
   public async getVersion() {
-    return this.Labels.version;
+    if (this.Labels && this.Labels.version) {
+      return this.Labels.version;
+    } else {
+      return '0.0.0';
+    }
   }
 }

ts/docker.classes.network.ts

@@ -1,7 +1,9 @@
-import * as plugins from './docker.plugins';
-import * as interfaces from './interfaces';
+import * as plugins from './docker.plugins.js';
+import * as interfaces from './interfaces/index.js';
 
-import { DockerHost } from './docker.classes.host';
+import { DockerHost } from './docker.classes.host.js';
+import { DockerService } from './docker.classes.service.js';
+import { logger } from './docker.logging.js';
 
 export class DockerNetwork {
   public static async getNetworks(dockerHost: DockerHost): Promise<DockerNetwork[]> {
@@ -17,7 +19,7 @@ export class DockerNetwork {
 
   public static async getNetworkByName(dockerHost: DockerHost, dockerNetworkNameArg: string) {
     const networks = await DockerNetwork.getNetworks(dockerHost);
-    return networks.find(dockerNetwork => dockerNetwork.Name === dockerNetworkNameArg);
+    return networks.find((dockerNetwork) => dockerNetwork.Name === dockerNetworkNameArg);
   }
 
   public static async createNetwork(
@@ -29,28 +31,25 @@ export class DockerNetwork {
       CheckDuplicate: true,
       Driver: 'overlay',
       EnableIPv6: false,
-      IPAM: {
+      /* IPAM: {
         Driver: 'default',
         Config: [
           {
-            Subnet: '172.20.10.0/16',
-            IPRange: '172.20.10.0/24',
-            Gateway: '172.20.10.11'
+            Subnet: `172.20.${networkCreationDescriptor.NetworkNumber}.0/16`,
+            IPRange: `172.20.${networkCreationDescriptor.NetworkNumber}.0/24`,
+            Gateway: `172.20.${networkCreationDescriptor.NetworkNumber}.11`
           }
         ]
-      },
-      Internal: true,
+      }, */
+      Internal: false,
       Attachable: true,
-      Ingress: false
+      Ingress: false,
     });
     if (response.statusCode < 300) {
-      plugins.smartlog.defaultLogger.log('info', 'Created network successfully');
+      logger.log('info', 'Created network successfully');
       return await DockerNetwork.getNetworkByName(dockerHost, networkCreationDescriptor.Name);
     } else {
-      plugins.smartlog.defaultLogger.log(
-        'error',
-        'There has been an error creating the wanted network'
-      );
+      logger.log('error', 'There has been an error creating the wanted network');
       return null;
     }
   }
@@ -90,4 +89,30 @@ export class DockerNetwork {
   public async remove() {
     const response = await this.dockerHost.request('DELETE', `/networks/${this.Id}`);
   }
+
+  public async getContainersOnNetwork(): Promise<
+    Array<{
+      Name: string;
+      EndpointID: string;
+      MacAddress: string;
+      IPv4Address: string;
+      IPv6Address: string;
+    }>
+  > {
+    const returnArray = [];
+    const response = await this.dockerHost.request('GET', `/networks/${this.Id}`);
+    for (const key of Object.keys(response.body.Containers)) {
+      returnArray.push(response.body.Containers[key]);
+    }
+
+    return returnArray;
+  }
+
+  public async getContainersOnNetworkForService(serviceArg: DockerService) {
+    const containersOnNetwork = await this.getContainersOnNetwork();
+    const containersOfService = containersOnNetwork.filter((container) => {
+      return container.Name.startsWith(serviceArg.Spec.Name);
+    });
+    return containersOfService;
+  }
 }

ts/docker.classes.secret.ts

@@ -1,8 +1,8 @@
-import * as plugins from './docker.plugins';
-import { DockerHost } from './docker.classes.host';
+import * as plugins from './docker.plugins.js';
+import { DockerHost } from './docker.classes.host.js';
 
 // interfaces
-import * as interfaces from './interfaces';
+import * as interfaces from './interfaces/index.js';
 
 export class DockerSecret {
   // STATIC
@@ -17,30 +17,36 @@ export class DockerSecret {
     return secrets;
   }
 
-  public static async getSecretByID (dockerHostArg: DockerHost, idArg: string) {
+  public static async getSecretByID(dockerHostArg: DockerHost, idArg: string) {
     const secrets = await this.getSecrets(dockerHostArg);
-    return secrets.find(secret => secret.ID === idArg);
+    return secrets.find((secret) => secret.ID === idArg);
   }
 
-  public static async getSecretByName (dockerHostArg: DockerHost, nameArg: string) {
+  public static async getSecretByName(dockerHostArg: DockerHost, nameArg: string) {
     const secrets = await this.getSecrets(dockerHostArg);
-    return secrets.find(secret => secret.Spec.Name === nameArg);
+    return secrets.find((secret) => secret.Spec.Name === nameArg);
   }
 
-  public static async createSecret(dockerHostArg: DockerHost, secretDescriptor: interfaces.ISecretCreationDescriptor) {
+  public static async createSecret(
+    dockerHostArg: DockerHost,
+    secretDescriptor: interfaces.ISecretCreationDescriptor
+  ) {
     const labels: interfaces.TLabels = {
       ...secretDescriptor.labels,
-      version: secretDescriptor.version
+      version: secretDescriptor.version,
     };
     const response = await dockerHostArg.request('POST', '/secrets/create', {
       Name: secretDescriptor.name,
       Labels: labels,
-      Data: plugins.smartstring.base64.encode(secretDescriptor.contentArg)
+      Data: plugins.smartstring.base64.encode(secretDescriptor.contentArg),
     });
-    
+
     const newSecretInstance = new DockerSecret(dockerHostArg);
     Object.assign(newSecretInstance, response.body);
-    Object.assign (newSecretInstance, await DockerSecret.getSecretByID(dockerHostArg, newSecretInstance.ID));
+    Object.assign(
+      newSecretInstance,
+      await DockerSecret.getSecretByID(dockerHostArg, newSecretInstance.ID)
+    );
     return newSecretInstance;
   }
 
@@ -51,7 +57,7 @@ export class DockerSecret {
     Labels: interfaces.TLabels;
   };
   public Version: {
-    Index:string;
+    Index: string;
   };
 
   public dockerHost: DockerHost;
@@ -62,22 +68,25 @@ export class DockerSecret {
   /**
    * updates a secret
    */
-  public async update (contentArg: string) {
+  public async update(contentArg: string) {
     const route = `/secrets/${this.ID}/update?=version=${this.Version.Index}`;
-    const response = await this.dockerHost.request('POST', `/secrets/${this.ID}/update?version=${this.Version.Index}`, {
-      Name: this.Spec.Name,
-      Labels: this.Spec.Labels,
-      Data: plugins.smartstring.base64.encode(contentArg)
-    });
+    const response = await this.dockerHost.request(
+      'POST',
+      `/secrets/${this.ID}/update?version=${this.Version.Index}`,
+      {
+        Name: this.Spec.Name,
+        Labels: this.Spec.Labels,
+        Data: plugins.smartstring.base64.encode(contentArg),
+      }
+    );
   }
 
-  public async remove () {
+  public async remove() {
     await this.dockerHost.request('DELETE', `/secrets/${this.ID}`);
   }
 
-
   // get things
   public async getVersion() {
     return this.Spec.Labels.version;
   }
-}
+}

ts/docker.classes.service.ts

@@ -1,9 +1,10 @@
-import * as plugins from './docker.plugins';
-import * as interfaces from './interfaces';
+import * as plugins from './docker.plugins.js';
+import * as interfaces from './interfaces/index.js';
 
-import { DockerHost } from './docker.classes.host';
-import { DockerImage } from './docker.classes.image';
-import { DockerSecret } from './docker.classes.secret';
+import { DockerHost } from './docker.classes.host.js';
+import { DockerImage } from './docker.classes.image.js';
+import { DockerSecret } from './docker.classes.secret.js';
+import { logger } from './docker.logging.js';
 
 export class DockerService {
   // STATIC
@@ -23,7 +24,7 @@ export class DockerService {
     networkName: string
   ): Promise<DockerService> {
     const allServices = await DockerService.getServices(dockerHost);
-    const wantedService = allServices.find(service => {
+    const wantedService = allServices.find((service) => {
       return service.Spec.Name === networkName;
     });
     return wantedService;
@@ -37,60 +38,141 @@ export class DockerService {
     serviceCreationDescriptor: interfaces.IServiceCreationDescriptor
   ): Promise<DockerService> {
     // lets get the image
-    plugins.smartlog.defaultLogger.log(
-      'info',
-      `now creating service ${serviceCreationDescriptor.name}`
-    );
-    
+    logger.log('info', `now creating service ${serviceCreationDescriptor.name}`);
+
     // await serviceCreationDescriptor.image.pullLatestImageFromRegistry();
     const serviceVersion = await serviceCreationDescriptor.image.getVersion();
 
     const labels: interfaces.TLabels = {
       ...serviceCreationDescriptor.labels,
-      version: serviceVersion
+      version: serviceVersion,
     };
 
-    const networkArray: any[] = [];
-    for (const network of serviceCreationDescriptor.networks) {
-      networkArray.push({
-        Target: network.Name,
-        Aliases: [serviceCreationDescriptor.networkAlias]
+    const mounts: Array<{
+      /**
+       * the target inside the container
+       */
+      Target: string;
+      /**
+       * The Source from which to mount the data (Volume or host path)
+       */
+      Source: string;
+      Type: 'bind' | 'volume' | 'tmpfs' | 'npipe';
+      ReadOnly: boolean;
+      Consistency: 'default' | 'consistent' | 'cached' | 'delegated';
+    }> = [];
+    if (serviceCreationDescriptor.accessHostDockerSock) {
+      mounts.push({
+        Target: '/var/run/docker.sock',
+        Source: '/var/run/docker.sock',
+        Consistency: 'default',
+        ReadOnly: false,
+        Type: 'bind',
       });
     }
 
+    if (serviceCreationDescriptor.resources && serviceCreationDescriptor.resources.volumeMounts) {
+      for (const volumeMount of serviceCreationDescriptor.resources.volumeMounts) {
+        mounts.push({
+          Target: volumeMount.containerFsPath,
+          Source: volumeMount.hostFsPath,
+          Consistency: 'default',
+          ReadOnly: false,
+          Type: 'bind',
+        });
+      }
+    }
+
+    const networkArray: Array<{
+      Target: string;
+      Aliases: string[];
+    }> = [];
+
+    for (const network of serviceCreationDescriptor.networks) {
+      networkArray.push({
+        Target: network.Name,
+        Aliases: [serviceCreationDescriptor.networkAlias],
+      });
+    }
+
+    const ports = [];
+    for (const port of serviceCreationDescriptor.ports) {
+      const portArray = port.split(':');
+      const hostPort = portArray[0];
+      const containerPort = portArray[1];
+      ports.push({
+        Protocol: 'tcp',
+        PublishedPort: parseInt(hostPort, 10),
+        TargetPort: parseInt(containerPort, 10),
+      });
+    }
+
+    // lets configure secrets
     const secretArray: any[] = [];
     for (const secret of serviceCreationDescriptor.secrets) {
       secretArray.push({
         File: {
-          Name: 'secret.json',
+          Name: 'secret.json', // TODO: make sure that works with multiple secrets
           UID: '33',
           GID: '33',
-          Mode: 384
+          Mode: 384,
         },
         SecretID: secret.ID,
-        SecretName: secret.Spec.Name
+        SecretName: secret.Spec.Name,
       });
     }
 
+    // lets configure limits
+
+    const memoryLimitMB =
+      serviceCreationDescriptor.resources && serviceCreationDescriptor.resources.memorySizeMB
+        ? serviceCreationDescriptor.resources.memorySizeMB
+        : 1000;
+
+    const limits = {
+      MemoryBytes: memoryLimitMB * 1000000,
+    };
+
+    if (serviceCreationDescriptor.resources) {
+      limits.MemoryBytes = serviceCreationDescriptor.resources.memorySizeMB * 1000000;
+    }
+
     const response = await dockerHost.request('POST', '/services/create', {
       Name: serviceCreationDescriptor.name,
       TaskTemplate: {
         ContainerSpec: {
           Image: serviceCreationDescriptor.image.RepoTags[0],
           Labels: labels,
-          Secrets: secretArray
+          Secrets: secretArray,
+          Mounts: mounts,
+          /* DNSConfig: {
+            Nameservers: ['1.1.1.1']
+          } */
         },
         UpdateConfig: {
           Parallelism: 0,
           Delay: 0,
           FailureAction: 'pause',
           Monitor: 15000000000,
-          MaxFailureRatio: 0.15
+          MaxFailureRatio: 0.15,
+        },
+        ForceUpdate: 1,
+        Resources: {
+          Limits: limits,
+        },
+        LogDriver: {
+          Name: 'json-file',
+          Options: {
+            'max-file': '3',
+            'max-size': '10M',
+          },
         },
-        ForceUpdate: 1
       },
-      Labels: serviceCreationDescriptor.labels,
-      Networks: networkArray
+      Labels: labels,
+      Networks: networkArray,
+      EndpointSpec: {
+        Ports: ports,
+      },
     });
 
     const createdService = await DockerService.getServiceByName(
@@ -136,32 +218,13 @@ export class DockerService {
     this.dockerHostRef = dockerHostArg;
   }
 
-  public async update() {
-    const labels: interfaces.TLabels = {
-      ...this.Spec.Labels,
-      version: 'x.x.x'
-    };
-
-    const dockerData = await this.dockerHostRef.request(
-      'POST',
-      `/services/${this.ID}/update?version=${this.Version.Index}`,
-      {
-        Name: this.Spec.Name,
-        TaskTemplate: this.Spec.TaskTemplate,
-        Labels: labels,
-        Networks: this.Spec.Networks
-      }
-    );
-    Object.assign(this, dockerData);
-  }
-
   public async remove() {
     await this.dockerHostRef.request('DELETE', `/services/${this.ID}`);
   }
 
   public async reReadFromDockerEngine() {
     const dockerData = await this.dockerHostRef.request('GET', `/services/${this.ID}`);
-    Object.assign(this, dockerData);
+    // TODO: Better assign: Object.assign(this, dockerData);
   }
 
   public async needsUpdate(): Promise<boolean> {
@@ -169,7 +232,7 @@ export class DockerService {
 
     await this.reReadFromDockerEngine();
     const dockerImage = await DockerImage.createFromRegistry(this.dockerHostRef, {
-      imageUrl: this.Spec.TaskTemplate.ContainerSpec.Image
+      imageUrl: this.Spec.TaskTemplate.ContainerSpec.Image,
     });
 
     const imageVersion = new plugins.smartversion.SmartVersion(dockerImage.Labels.version);
@@ -181,10 +244,4 @@ export class DockerService {
       console.log(`service ${this.Spec.Name} is up to date.`);
     }
   }
-
-  public async updateFromRegistry() {
-    if (await this.needsUpdate()) {
-      this.update();
-    }
-  }
 }

ts/docker.logging.ts

@@ -0,0 +1,3 @@
+import * as plugins from './docker.plugins.js';
+
+export const logger = new plugins.smartlog.ConsoleLog();

ts/docker.plugins.ts

@@ -1,25 +1,37 @@
 // node native path
 import * as path from 'path';
 
-export {
-  path
-};
+export { path };
 
 // @pushrocks scope
-import * as lik from '@pushrocks/lik';
-import * as smartfile from '@pushrocks/smartfile';
-import * as smartjson from '@pushrocks/smartjson';
-import * as smartlog from '@pushrocks/smartlog';
-import * as smartnetwork from '@pushrocks/smartnetwork';
-import * as smartpath from '@pushrocks/smartpath';
-import * as smartpromise from '@pushrocks/smartpromise';
-import * as smartrequest from '@pushrocks/smartrequest';
-import * as smartstring from '@pushrocks/smartstring';
-import * as smartversion from '@pushrocks/smartversion';
+import * as lik from '@push.rocks/lik';
+import * as smartfile from '@push.rocks/smartfile';
+import * as smartjson from '@push.rocks/smartjson';
+import * as smartlog from '@push.rocks/smartlog';
+import * as smartnetwork from '@push.rocks/smartnetwork';
+import * as smartpath from '@push.rocks/smartpath';
+import * as smartpromise from '@push.rocks/smartpromise';
+import * as smartrequest from '@push.rocks/smartrequest';
+import * as smartstring from '@push.rocks/smartstring';
+import * as smartversion from '@push.rocks/smartversion';
 
-smartlog.defaultLogger.enableConsole();
+export {
+  lik,
+  smartfile,
+  smartjson,
+  smartlog,
+  smartnetwork,
+  smartpath,
+  smartpromise,
+  smartrequest,
+  smartstring,
+  smartversion,
+};
 
-export { lik, smartfile, smartjson, smartlog, smartnetwork, smartpath, smartpromise, smartrequest, smartstring, smartversion };
+// @tsclass scope
+import * as tsclass from '@tsclass/tsclass';
+
+export { tsclass };
 
 // third party
 import * as rxjs from 'rxjs';

ts/index.ts

@@ -1,6 +1,6 @@
-export * from './docker.classes.host';
-export * from './docker.classes.container';
-export * from './docker.classes.image';
-export * from './docker.classes.network';
-export * from './docker.classes.secret';
-export * from './docker.classes.service';
+export * from './docker.classes.host.js';
+export * from './docker.classes.container.js';
+export * from './docker.classes.image.js';
+export * from './docker.classes.network.js';
+export * from './docker.classes.secret.js';
+export * from './docker.classes.service.js';

ts/interfaces/container.ts

@@ -1,4 +1,4 @@
-import { DockerNetwork } from '../docker.classes.network';
+import { DockerNetwork } from '../docker.classes.network.js';
 
 export interface IContainerCreationDescriptor {
   Hostname: string;

ts/interfaces/index.ts

@@ -1,7 +1,7 @@
-export * from './container';
-export * from './image';
-export * from './label';
-export * from './network';
-export * from './port';
-export * from './secret';
-export * from './service';
+export * from './container.js';
+export * from './image.js';
+export * from './label.js';
+export * from './network.js';
+export * from './port.js';
+export * from './secret.js';
+export * from './service.js';

ts/interfaces/secret.ts

@@ -1,8 +1,8 @@
-import * as interfaces from './';
+import * as interfaces from './index.js';
 
 export interface ISecretCreationDescriptor {
   name: string;
   version: string;
   contentArg: any;
   labels: interfaces.TLabels;
-}
+}

ts/interfaces/service.ts

@@ -1,7 +1,9 @@
-import * as interfaces from './';
-import { DockerNetwork } from '../docker.classes.network';
-import { DockerSecret } from '../docker.classes.secret';
-import { DockerImage } from '../docker.classes.image';
+import * as plugins from '../docker.plugins.js';
+
+import * as interfaces from './index.js';
+import { DockerNetwork } from '../docker.classes.network.js';
+import { DockerSecret } from '../docker.classes.secret.js';
+import { DockerImage } from '../docker.classes.image.js';
 
 export interface IServiceCreationDescriptor {
   name: string;
@@ -10,4 +12,10 @@ export interface IServiceCreationDescriptor {
   networks: DockerNetwork[];
   networkAlias: string;
   secrets: DockerSecret[];
+  ports: string[];
+  accessHostDockerSock?: boolean;
+  resources?: {
+    memorySizeMB?: number;
+    volumeMounts?: plugins.tsclass.container.IVolumeMount[];
+  };
 }

tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "experimentalDecorators": true,
+    "useDefineForClassFields": false,
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "esModuleInterop": true,
+    "verbatimModuleSyntax": true
+  },
+  "exclude": [
+    "dist_*/**/*.d.ts"
+  ]
+}

tslint.json

@@ -1,17 +0,0 @@
-{
-  "extends": ["tslint:latest", "tslint-config-prettier"],
-  "rules": {
-    "semicolon": [true, "always"],
-    "no-console": false,
-    "ordered-imports": false,
-    "object-literal-sort-keys": false,
-    "member-ordering": {
-      "options":{
-        "order": [
-          "static-method"
-        ]
-      }
-    }
-  },
-  "defaultSeverity": "warning"
-}