Adding simple get (#2)

* - Simple ts-get added for better typings in corner cases

* - Deploy and build scripts are fixed. Few other improvements

Author: RIP21

.babelrc

@@ -0,0 +1,14 @@
+{
+  "comments": false,
+  "presets": [
+    [
+      "@babel/preset-env",
+      {
+        "targets": {
+          "node": "10"
+        }
+      }
+    ],
+    "@babel/preset-typescript"
+  ]
+}

.gitignore

@@ -50,7 +50,7 @@ npm-debug.log.*
 /selenium-debug.log
 /grocerycop-website-3.1-ui.iml
 /.vscode/
-/lib/
+/**/lib
 /.env.local
 /styleguide/
 /storybook-static/

README.md

@@ -7,6 +7,12 @@ Alternative to `lodash.get` that makes it typed and cool as if optional chaining
 
 Means you're not only safely navigate object, but you're also getting 100% autocomplete and type-safeness 🎉
 
+## Important
+
+There is also `ts-get-simple` that is exactly the same, but will require you to use `!` to be able to chain, it improves some corner cases 
+(e.g. when you chain to some object, and non primitive, it will persist original nested type)
+Take a look at the examples below.
+
 ## Usage and examples
 
 ```typescript
@@ -19,26 +25,87 @@ import get from 'ts-get'
   }
  } | undefined | null
 
- const input: SomeType = {}
- const input2: SomeType = {
+ const emptyObject: SomeType = {}
+ const withOneOptionalField: SomeType = {
     optionalField: "value",
  }
 
- get(input, it => it.optionalField, "default") // -> "default"
- get(input2, it => it.optionalField, "default") // -> "value"
- get(input2, it => it.nested.dangerousAccess, "default") // -> "default"
- get(input2, it => it.unknownField, "default") // -> Type error, `unknownField` doesn't exist on type
- get(input2, it => it.optionalField, 5) // -> Type error, third argument is not assignable to type `string`
+ get(emptyObject, it => it.optionalField, "default") // -> "default"
+ get(withOneOptionalField, it => it.optionalField, "default") // -> "value"
+ get(withOneOptionalField, it => it.nested.dangerousAccess, "default") // -> "default"
+ get(withOneOptionalField, it => it.unknownField, "default") // -> Type error, `unknownField` doesn't exist on type
+ get(withOneOptionalField, it => it.optionalField, 5) // -> Type error, third argument is not assignable to type `string`
 ```
 
 ## Difference with `lodash.get` behavior
 
 - If your path gets `null` at the end, it will bail out to `defaultValue` or `undefined`. 
 If you would like to get `null` returned anyway, just pass it as a `defaultValue`
+
+## Known issues:
 - If your type field is of type `null` and only `null` or `undefined` your field will be of type `{}[]`. 
 I have no idea how to fix it 🤷‍♂️ PR Welcome 😇🙏
 ```typescript
 type A = {
   field: null | undefined// -> {}[] inside of the callback and as return type too
 }
-```
+
+```
+- If you return not a primitive but an object, all its nested fields will be `Required` e.g. all `undefined` and `null` will be removed.
+```typescript
+import get from 'ts-get'
+type A = {
+  field?: {
+    optional?: string | null
+  }
+}
+const input: A = {}
+const res = get(input, it => it.field)
+res // <== Will be inferred as { optional: string }, without null and ? (undefined) which is wrong, but seems to be impossible to infer.
+
+```
+
+
+# ts-get-simple
+[![npm version](https://badge.fury.io/js/ts-get.svg)](https://badge.fury.io/js/ts-get-simple)
+
+
+
+## Usage and examples `ts-get-simple`
+
+```typescript
+import get from 'ts-get-simple'
+
+ type SomeType = {
+  optionalField?: string
+  nested?: {
+    dangerousAccess?: string
+  }
+ } | undefined | null
+ 
+ const emptyObject: SomeType = {}
+ const withOneOptionalField: SomeType = {
+    optionalField: "value",
+ }
+ 
+get(emptyObject, it => it!.optionalField, "default") // -> "default"
+get(withOneOptionalField, it => it!.optionalField, "default") // -> "value"
+get(withOneOptionalField, it => it!.nested!.dangerousAccess, "default") // -> "default"
+get(withOneOptionalField, it => it!.unknownField, "default") // -> Type error, `unknownField` doesn't exist on type
+get(withOneOptionalField, it => it!.optionalField, 5) // -> Type error, third argument is not assignable to type `string | undefined`
+```
+
+## Known typing issues of `ts-get-simple`
+
+```typescript
+ import get from 'ts-get-simple'
+ 
+ type SomeType = {
+   nested?: string | null 
+ }
+ const input: SomeType = {}
+ const cannotBeNull = get(input, it => it!.nested) // <== will be inferred as string | null | undefined, while it really cannot be `null` by logic
+ const canBeNull = get(input, it => it!.nested, null) // <== will be inferred as string, while it really should be string | null
+ const canBeUndefined = get(input, it => it!.nested, undefined) // <== will be inferred as string, while it really should be string | undefined
+```
+Last one is stupid, but just for your information.

package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-get",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "Alternative to lodash.get that makes it typed and cool as if optional chaining proposal is there",
   "main": "lib/index.node.js",
   "module": "lib/index.js",
@@ -9,49 +9,40 @@
   "repository": "https://github.com/RIP21/ts-get.git",
   "author": "Andrii Los <puha212@gmail.com>",
   "license": "MIT",
-  "private": false,
+  "private": true,
   "scripts": {
     "lint": "prettier --write ./**/*.ts",
-    "prebuild": "rimraf lib",
-    "build": "tsc && babel src/index.ts --out-file lib/index.node.js",
+    "clean": "rimraf src/ts-get/lib && rimraf src/ts-get-simple/lib && mkdir src/ts-get/lib && mkdir src/ts-get-simple/lib",
+    "prebuild": "yarn clean",
+    "build:smart": "tsc -p src/ts-get/tsconfig.json && babel src/ts-get/index.ts --out-file src/ts-get/lib/index.node.js  --config-file ./.babelrc",
+    "build:simple": "tsc -p src/ts-get-simple/tsconfig.json && babel src/ts-get-simple/index.ts --out-file src/ts-get-simple/lib/index.node.js --config-file ./.babelrc",
+    "build": "run-p build:*",
     "test": "jest src --coverage",
     "test:codecov": "jest src --coverage && codecov",
     "prepublish": "yarn build",
-    "release": "np"
+    "release:smart": "cd src/ts-get && np --any-branch && cd ../..",
+    "release:simple": "cd src/ts-get-simple && np --any-branch && cd ../..",
+    "release": "run-s release:*"
   },
   "devDependencies": {
     "@babel/cli": "^7.2.3",
-    "@babel/core": "^7.3.4",
+    "@babel/core": "^7.4.0",
     "@babel/plugin-syntax-typescript": "^7.3.3",
-    "@babel/preset-env": "^7.3.4",
+    "@babel/preset-env": "^7.4.2",
     "@babel/preset-typescript": "^7.3.3",
-    "@babel/runtime": "^7.3.4",
+    "@babel/runtime": "^7.4.2",
     "@types/jest": "^24.0.11",
     "@types/lodash": "^4.14.123",
     "codecov": "^3.2.0",
     "jest": "^24.5.0",
     "lodash": "^4.17.11",
-    "np": "^4.0.2",
+    "npm-run-all": "^4.1.5",
     "prettier": "^1.16.4",
-    "rimraf": "^2.6.3",
-    "ts-jest": "^24.0.0",
-    "typescript": "^3.3.3333"
+    "rimraf": "2.6.3",
+    "ts-jest": "24.0.1",
+    "typescript": "3.4.1"
   },
   "files": [
     "lib"
-  ],
-  "babel": {
-    "comments": false,
-    "presets": [
-      [
-        "@babel/preset-env",
-        {
-          "targets": {
-            "node": "10"
-          }
-        }
-      ],
-      "@babel/preset-typescript"
-    ]
-  }
+  ]
 }

src/ts-get-simple/index.test.ts

@@ -0,0 +1,87 @@
+import { get } from './'
+import { get as _get } from 'lodash'
+
+describe('get', function() {
+  type InputType = {
+    a: string
+    b?: {
+      nested?: string | null
+    }
+  }
+  const inputAllPresent: InputType = {
+    a: 'Value',
+    b: {
+      nested: 'Value',
+    },
+  }
+  const inputOptionalsMissing: InputType = {
+    a: 'Value',
+  }
+  const inputOptionalsSafeAccessMissing: InputType = {
+    a: 'Value',
+    b: {}, // accessing b.nested will return undefined and will not throw error
+  }
+  it('should return value', () => {
+    const result = get(inputAllPresent, it => it.a)
+    expect(result).toBe('Value')
+  })
+  it('should return value on existing optional field', () => {
+    const result = get(inputAllPresent, it => it!.b!.nested, 'Default')
+    expect(result).toBe('Value')
+  })
+  it('should return undefined on non existing optional field', () => {
+    const result = get(inputOptionalsMissing, it => it!.b!.nested) // Here is wrong typings, it's string | null | undefined, where is should be only string | undefined
+    expect(result).toBeUndefined()
+  })
+  it('should return defaultValue on non existing optional field', () => {
+    const result = get(inputOptionalsMissing, it => it!.b!.nested, 'Default')
+    expect(result).toBe('Default')
+  })
+  it('should return defaultValue on non existing optional field', () => {
+    const result = get(inputOptionalsMissing, it => it!.b!.nested, 'Default')
+    expect(result).toBe('Default')
+  })
+
+  it('should replica lodash interface in cases below', () => {
+    const result1 = get(inputAllPresent, it => it.a)
+    const result1_ = _get(inputAllPresent, 'a')
+
+    const result2 = get(inputAllPresent, it => it!.b!.nested, 'Default')
+    const result2_ = _get(inputAllPresent, 'b.nested', 'Default')
+
+    const result3 = get(inputOptionalsMissing, it => it!.b!.nested) // Here is wrong typings, it's string | null | undefined, where is should be only string | undefined
+    const result3_ = _get(inputOptionalsMissing, 'b.nested')
+
+    const result4 = get(inputOptionalsSafeAccessMissing, it => it!.b!.nested, 'Default')
+    const result4_ = _get(inputOptionalsSafeAccessMissing, 'b.nested', 'Default')
+
+    expect(result1).toBe(result1_)
+    expect(result2).toBe(result2_)
+    expect(result3).toBe(result3_)
+    expect(result4).toBe(result4_)
+  })
+  it('should return undefined and default value in case of null (different from _.get)', function() {
+    const inputWithNull: InputType = {
+      a: 'Value',
+      b: {
+        nested: null,
+      },
+    }
+    const defaultedNull = get( // Here is wrong typings, it's string | null, but it says string
+      inputOptionalsMissing,
+      it => it!.b!.nested,
+      null,
+    )
+    expect(defaultedNull).toBe(null)
+
+    const undefinedFromNullValue = get(inputWithNull, it => it!.b!.nested) // Here is wrong typings, it's string | null | undefined, where is should be only string | undefined
+    expect(undefinedFromNullValue).toBeUndefined()
+
+    const defaultedStringFromNullValue = get(
+      inputWithNull,
+      it => it!.b!.nested,
+      'Default',
+    )
+    expect(defaultedStringFromNullValue).toBe('Default')
+  })
+})

src/ts-get-simple/index.ts

@@ -0,0 +1,23 @@
+export type AccessorFunction<T, R> = (object: T) => R
+
+export function get<T, R>(object: T, accessorFn: AccessorFunction<T, R>): Exclude<R, null> | undefined
+export function get<T, R>(
+  object: T,
+  accessorFn: AccessorFunction<T, R>,
+  defaultValue: R,
+): Exclude<R, undefined | null>
+
+export function get<T, R>(
+  object: T,
+  accessorFn: AccessorFunction<T, R>,
+  defaultValue?: R,
+): R | undefined {
+  try {
+    const result = accessorFn(object)
+    return result === undefined || result === null ? defaultValue : result
+  } catch (e) {
+    return defaultValue
+  }
+}
+
+export default get

src/ts-get-simple/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "simple-ts-get",
+  "version": "1.0.4",
+  "description": "Alternative to lodash.get that makes it typed and cool as if optional chaining proposal is there",
+  "main": "lib/index.node.js",
+  "module": "lib/index.js",
+  "jsnext:main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "repository": "https://github.com/RIP21/ts-get.git",
+  "author": "Andrii Los <puha212@gmail.com>",
+  "license": "MIT",
+  "private": false,
+  "files": [
+    "lib"
+  ]
+}

src/ts-get-simple/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "baseUrl": "./",
+    "lib": ["es6", "dom", "es2016", "es2017"],
+    "module": "esnext",
+    "moduleResolution": "node",
+    "strict": true,
+    "outDir": "lib",
+    "declaration": true,
+    "esModuleInterop": true,
+    "sourceMap": true
+  },
+  "exclude": [
+    "/**/index.test.ts"
+  ]
+}

src/index.test.ts src/ts-get/index.test.tssrc/index.test.ts renamed to src/ts-get/index.test.ts

@@ -19,7 +19,7 @@ describe('get', function() {
   }
   const inputOptionalsSafeAccessMissing: InputType = {
     a: 'Value',
-    b: {} // accessing b.nested will return undefined and will not throw error
+    b: {}, // accessing b.nested will return undefined and will not throw error
   }
   it('should return value', () => {
     const result = get(inputAllPresent, it => it.a)
@@ -55,7 +55,6 @@ describe('get', function() {
     const result4 = get(inputOptionalsSafeAccessMissing, it => it.b.nested, 'Default')
     const result4_ = _get(inputOptionalsSafeAccessMissing, 'b.nested', 'Default')
 
-
     expect(result1).toBe(result1_)
     expect(result2).toBe(result2_)
     expect(result3).toBe(result3_)
@@ -68,13 +67,17 @@ describe('get', function() {
         nested: null,
       },
     }
-    const defaultedNull = get<InputType, string | null>(inputOptionalsMissing, it => it.b.nested, null)
+    const defaultedNull = get<InputType, string | null>(
+      inputOptionalsMissing,
+      it => it.b.nested,
+      null,
+    )
     expect(defaultedNull).toBe(null)
 
     const undefinedFromNullValue = get(inputWithNull, it => it.b.nested)
     expect(undefinedFromNullValue).toBeUndefined()
 
-    const defaultedStringFromNullValue = get(inputWithNull, it => it.b.nested, "Default")
-    expect(defaultedStringFromNullValue).toBe("Default")
+    const defaultedStringFromNullValue = get(inputWithNull, it => it.b.nested, 'Default')
+    expect(defaultedStringFromNullValue).toBe('Default')
   })
 })