phenyl / sp2 Goto Github PK

example code:

import { $bind } from "@sp2/updater";

type Hoge = {
  fuga: {
    key1: string;
    key2: string;
  };
};

const { $push, $path } = $bind<Hoge>();

$push($path("fuga", "key1"), "hoge"); // valid

const key = Math.random() > 0.5 ? "key1" : "key2";

$push($path("fuga", key), "hoge"); // $path is type error

I see here.
https://github.com/phenyl-js/sp2/blob/5c14b6d31cf228b8403c2f184787eb02cbe41c80/modules/format/src/common/bound-document-path.ts#L21-L28
https://github.com/phenyl-js/sp2/blob/5c14b6d31cf228b8403c2f184787eb02cbe41c80/modules/format/src/common/bound-document-path.ts#L151-L154

The $path method is generating some depth path type and this using like following codes.
K1 extends keyof T, K2 extends keyof T[K1] ...
However if type K[i] had union type value, looks like TS compiler is checking 'left side value can extends all of expanded union type value?'.
And i think this issue can be solved by using like following codes.
K1 extends Extract<K1, keyof T>, K2 extends Extract<K2, T[K1]> ...

But if resolved this issue, #37 Error is still showing...

sp2 provides slightly different formats from MongoDB's formats.
To fill the gap, sp2 should provide converters of operations.

function toMongoUpdateOperation(operation: GeneralUpdateOperation): GeneralUpdateOperation

function toMongoFindOperation(operation: FindOperation): FindOperation

DocumentPath [1] is wrongly converted into DotNotationString .1.
1 is expected.

import { $bind } from 'sp2'

type SomeType = {
    exact: {
        deepNestedExact: {
            count: number
        }
    },
    optional?: {
        deepNestedOptional?: {
            count: number
        }
    }
}

const { $path } = $bind<SomeType>()

$path('exact', 'deepNestedExact', 'count') // OK
$path('optional', 'deepNestedOptional') // Error: Argument of type '"deepNestedOptional"' is not assignable to parameter of type 'never'.

Hi.
I found an error according to the optional property.

How can I traverse optional property?

https://docs.mongodb.com/manual/reference/operator/update/positional-all/

The all positional operator $[] indicates that the update operator should modify all elements in the specified array field

$append operator is syntax sugar for $set operator.

{ $set: { 'obj.foo': 123, 'obj.bar': 'abc', 'obj.baz': true } }

can be written as

{ $append: { obj: { foo: 123, bar: 'abc', baz: true } }

https://docs.mongodb.com/manual/reference/operator/update/positional/

The positional $ operator identifies an element in an array to update without explicitly specifying the position of the element in the array.

Explanation for restorable in README has a link to is-restorable module, but the link does not exist anymore.

As mongodb throws errors when an update operation ($set, $push, etc...) has no fields, update() function should follow the spec.

using $pull with $bind causes the following type error
Type instantiation is excessively deep and possibly infinite. ts(2589)

CircleCI-based coveralls doesn't seem to work. We should move on to CoverAlls-GitHub.
https://github.com/marketplace/actions/coveralls-github-action

https://docs.mongodb.com/manual/reference/operator/update/pullAll/

The $pullAll operator removes all instances of the specified values from an existing array. Unlike the $pull operator that removes elements by specifying a query, $pullAll removes elements that match the listed values.

I forked sp2 into my git and executed static analysis by using two types of tools: SonarCloud and DeepScan. The results between them are different because the analysis policies and the rules used by each other are different.

I'm sure your review will be helpful to others.
Click the badge below to see results.

1. results analyzed by DeepScan:

2. results analyzed by SonarCloud:

FYI
SonarCloud ( https://sonarcloud.io/ )

• analysis on 20+ different languages (including Javascript)
• possible to analyze source from various perspectives:
  Reliability,
  Security (Hotspot, OWASPs Top 10, SNAS Top 25, CWE),
  Maintainability,
  Coverage,
  Duplications,
  Complexity
• A total of 226 rules are applied to Javascript and 172 to TypeScript

DeepScan ( https://deepscan.io/ )

• specialized in Javascript ( JavaScript, TypeScript, React and Vue.js )
• semantic analysis (enables finding issues that syntax-based linters can't)
• analyzed by using ESLint and 201 rules (As of June 5, 2020)

Add benchmark tests on benchmark module.

• create module

update()

• non-nested $set operation
• nested $set operation
• $push operation
• mixed operation
• comparison with immer
• comparison with Immutable.js
• comparison with other state-updating libraries

retrieve()

• simple find operation
• mixed operation

type TargetObject<T> = { foo: T };

function bar<T>(obj: TargetObject<T>, value: T) {
  const { $set, $docPath } = $bind<TargetObject<T>>();
  const path = $docPath("foo");
  const operation = $set(path, value); // this occurs an error
}

Maybe type inference at 2nd argument of $set is not working.

  const operation = $set(path, value as NestedValue<TargetObject<T>, "foo", "","","","","","","","",""); 

This can suppress the error, but I want easier way.