Logger

.github/workflows/nodejs.yml

@@ -4,7 +4,7 @@ on:
   push:
     branches:
       - master
-      - better-inference
+      - logger
 
 jobs:
   build:

packages/effect/src/freeEnv.ts

@@ -13,22 +13,23 @@ export type Patched<A, B> = B extends FunctionN<
 
 export type Derived<A extends ModuleShape<A>> = {
   [k in keyof A]: {
-    [h in keyof A[k]]: Patched<A, A[k][h]>
-  }
-}
+    [h in keyof A[k]]: Patched<A, A[k][h]>;
+  };
+};
 
 export function access<A extends ModuleShape<A>>(
   sp: ModuleSpec<A> | A
 ): Derived<A> {
   const derived = {} as Derived<A>;
-  const a: ModuleShape<A> = sp[specURI] ?? sp
+  const a: ModuleShape<A> = sp[specURI] ?? sp;
 
   for (const s of Reflect.ownKeys(a)) {
-    derived[s] = {}
+    derived[s] = {};
 
     for (const k of Object.keys(a[s])) {
       if (typeof a[s][k] === "function") {
-        derived[s][k] = (...args: any[]) => T.accessM((r: A) => r[s][k](...args));
+        derived[s][k] = (...args: any[]) =>
+          T.accessM((r: A) => r[s][k](...args));
       } else {
         derived[s][k] = T.accessM((r: A) => r[s][k]);
       }
@@ -49,7 +50,7 @@ export type ModuleShape<M> = {
     };
 };
 
-export const specURI: unique symbol = Symbol()
+export const specURI: unique symbol = Symbol();
 
 export interface ModuleSpec<M> {
   [specURI]: ModuleShape<M>;
@@ -169,3 +170,9 @@ export function implement<S extends ModuleSpec<any>>(s: S) {
       pipe(eff, T.provideS(providing(s, i, e)))
     );
 }
+
+export function instance<S extends ModuleSpec<any>>(
+  _: S
+) {
+  return (m: TypeOf<S>) => m;
+}

packages/effect/tests/FreeEnv.test.ts

@@ -105,16 +105,17 @@ describe("Generic", () => {
       }
     });
 
-    const configI = F.implement(configM)({
-      [configEnv]: {
-        accessConfig: T.pure("")
-      }
-    });
-
-    const main = pipe(program, consoleI, prefixI, configI);
+    const main = pipe(program, consoleI, prefixI);
 
     assert.deepEqual(
-      await T.runToPromiseExit(T.provideAll(fnLive)(main)),
+      await T.runToPromiseExit(T.provideAll({
+        ...fnLive,
+        ...F.instance(configM)({
+          [configEnv]: {
+            accessConfig: T.pure("")
+          }
+        })
+      })(main)),
       done(["(prefix: message)"])
     );
   });

packages/logger/README.md

@@ -0,0 +1,2 @@
+# Notes
+The best place to look for concrete usage are tests & demo folders of each package

packages/logger/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@matechs/logger",
+  "version": "0.0.0",
+  "license": "MIT",
+  "private": false,
+  "repository": "https://github.com/mikearnaldi/matechs-effect.git",
+  "scripts": {
+    "build": "rimraf lib && tsc --build tsconfig.build.json",
+    "lint": "tslint --project ."
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "lib/index.js",
+  "files": [
+    "lib"
+  ],
+  "peerDependencies": {
+    "fp-ts": "^2.2.0",
+    "fp-ts-contrib": "^0.1.6"
+  },
+  "dependencies": {
+    "@matechs/effect": "^0.4.8"
+  },
+  "gitHead": "2ff0a2daa194950901aba13f3431b2470889f9c2"
+}

packages/logger/src/console.ts

@@ -0,0 +1,78 @@
+import { effect as T, freeEnv as F } from "@matechs/effect";
+import * as L from "./logger";
+import { Do } from "fp-ts-contrib/lib/Do";
+
+function format(level: L.Level, message: string, meta?: L.Meta) {
+  return `${level}: ${message}${meta ? `(${JSON.stringify({ meta })})` : ""}`;
+}
+
+function log(
+  config: T.UIO<Config>,
+  level: L.Level,
+  message: string,
+  meta?: L.Meta
+): T.UIO<void> {
+  return (
+    Do(T.effect)
+      .bind("config", config)
+      .bindL("formatter", s => T.pure(s.config.formatter ?? format))
+      .bindL("level", s => T.pure(s.config.level ?? "silly"))
+      .bindL("msg", s => T.pure(s.formatter(level, message, meta)))
+      .doL(({ msg, level: configLevel }) =>
+        T.when(L.severity[configLevel] >= L.severity[level])(
+          T.sync(() => {
+            switch (level) {
+              case "info":
+                // tslint:disable-next-line: no-console
+                console.info(msg);
+                break;
+              case "debug":
+                // tslint:disable-next-line: no-console
+                console.debug(msg);
+                break;
+              case "error":
+                // tslint:disable-next-line: no-console
+                console.error(msg);
+                break;
+              case "http":
+                // tslint:disable-next-line: no-console
+                console.info(msg);
+                break;
+              case "silly":
+                // tslint:disable-next-line: no-console
+                console.debug(msg);
+                break;
+              case "verbose":
+                // tslint:disable-next-line: no-console
+                console.debug(msg);
+                break;
+              case "warn":
+                // tslint:disable-next-line: no-console
+                console.warn(msg);
+                break;
+            }
+          })
+        )
+      )
+      // tslint:disable-next-line: no-empty
+      .return(() => {})
+  );
+}
+
+export interface Config {
+  formatter?: typeof format;
+  level?: L.Level;
+}
+
+export const consoleLogger = (config: T.UIO<Config> = T.pure({})) =>
+  F.instance(L.loggerM)({
+    [L.loggerEnv]: {
+      debug: (message, meta) => log(config, "debug", message, meta),
+      http: (message, meta) => log(config, "http", message, meta),
+      silly: (message, meta) => log(config, "silly", message, meta),
+      error: (message, meta) => log(config, "error", message, meta),
+      info: (message, meta) => log(config, "info", message, meta),
+      verbose: (message, meta) => log(config, "verbose", message, meta),
+      warn: (message, meta) => log(config, "warn", message, meta)
+    }
+  });

packages/logger/src/index.ts

@@ -0,0 +1,4 @@
+import * as logger from "./logger";
+import * as console from "./console";
+
+export { logger, console };

packages/logger/src/logger.ts

@@ -0,0 +1,37 @@
+import { effect as T, freeEnv as F } from "@matechs/effect";
+
+export const loggerEnv: unique symbol = Symbol();
+
+export interface Meta {
+  [k: string]: any;
+}
+
+export const loggerM = F.define({
+  [loggerEnv]: {
+    silly: F.fn<(message: string, meta?: Meta) => T.UIO<void>>(),
+    debug: F.fn<(message: string, meta?: Meta) => T.UIO<void>>(),
+    verbose: F.fn<(message: string, meta?: Meta) => T.UIO<void>>(),
+    http: F.fn<(message: string, meta?: Meta) => T.UIO<void>>(),
+    info: F.fn<(message: string, meta?: Meta) => T.UIO<void>>(),
+    warn: F.fn<(message: string, meta?: Meta) => T.UIO<void>>(),
+    error: F.fn<(message: string, meta?: Meta) => T.UIO<void>>()
+  }
+});
+
+export type Logger = F.TypeOf<typeof loggerM>;
+
+export type Level = keyof Logger[typeof loggerEnv];
+
+export const severity: Record<Level, number> = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  http: 3,
+  verbose: 4,
+  debug: 5,
+  silly: 6
+};
+
+export const {
+  [loggerEnv]: { silly, debug, verbose, http, info, warn, error }
+} = F.access(loggerM);

packages/logger/tests/Logger.test.ts

@@ -0,0 +1,102 @@
+import { effect as T } from "@matechs/effect";
+import * as L from "../src";
+import { pipe } from "fp-ts/lib/pipeable";
+import * as assert from "assert";
+import { isDone } from "@matechs/effect/lib/exit";
+
+// tslint:disable-next-line: no-empty
+const empty = () => {};
+
+const withEnv = T.provideAll(L.console.consoleLogger());
+
+describe("Logger", () => {
+  const info = jest.spyOn(console, "info");
+  const warn = jest.spyOn(console, "warn");
+  const debug = jest.spyOn(console, "debug");
+  const error = jest.spyOn(console, "error");
+
+  info.mockImplementation(empty);
+  warn.mockImplementation(empty);
+  debug.mockImplementation(empty);
+  error.mockImplementation(empty);
+
+  it("use logger", async () => {
+    assert.deepEqual(
+      isDone(await T.runToPromiseExit(pipe(L.logger.info("ok"), withEnv))),
+      true
+    );
+
+    assert.deepEqual(info.mock.calls.length, 1);
+
+    assert.deepEqual(
+      isDone(await T.runToPromiseExit(pipe(L.logger.http("ok"), withEnv))),
+      true
+    );
+
+    assert.deepEqual(info.mock.calls.length, 2);
+
+    assert.deepEqual(
+      isDone(await T.runToPromiseExit(pipe(L.logger.debug("ok"), withEnv))),
+      true
+    );
+
+    assert.deepEqual(debug.mock.calls.length, 1);
+
+    assert.deepEqual(
+      isDone(await T.runToPromiseExit(pipe(L.logger.silly("ok"), withEnv))),
+      true
+    );
+
+    assert.deepEqual(debug.mock.calls.length, 2);
+
+    assert.deepEqual(
+      isDone(await T.runToPromiseExit(pipe(L.logger.verbose("ok"), withEnv))),
+      true
+    );
+
+    assert.deepEqual(debug.mock.calls.length, 3);
+
+    assert.deepEqual(
+      isDone(await T.runToPromiseExit(pipe(L.logger.warn("ok"), withEnv))),
+      true
+    );
+
+    assert.deepEqual(warn.mock.calls.length, 1);
+
+    assert.deepEqual(
+      isDone(await T.runToPromiseExit(pipe(L.logger.error("ok"), withEnv))),
+      true
+    );
+
+    assert.deepEqual(error.mock.calls.length, 1);
+
+    assert.deepEqual(
+      isDone(
+        await T.runToPromiseExit(
+          pipe(L.logger.error("ok", { foo: "ok" }), withEnv)
+        )
+      ),
+      true
+    );
+
+    assert.deepEqual(error.mock.calls.length, 2);
+
+    assert.deepEqual(
+      isDone(
+        await T.runToPromiseExit(
+          pipe(
+            L.logger.debug("ok"),
+            T.provideAll(
+              L.console.consoleLogger(
+                T.pure<L.console.Config>({ level: "info" })
+              )
+            )
+          )
+        )
+      ),
+      true
+    );
+
+    assert.deepEqual(debug.mock.calls.length, 3);
+  });
+});

packages/logger/tsconfig.build.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../base.tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "lib",
+    "lib": ["DOM"]
+  },
+  "exclude": ["tests", "node_modules"]
+}

packages/logger/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../base.tsconfig.json",
+  "compilerOptions": {
+    "strict": false,
+    "rootDir": "./",
+    "outDir": "./lib",
+    "lib": ["DOM"],
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true
+  }
+}