Class DeepClient<L>

Type Parameters

Hierarchy (view full)

Implements

Constructors

constructor

Properties

apolloClient canSelectReturning? client deep DeepClient DeepContext DeepProvider defaultDeleteName? defaultInsertName? defaultSelectName? defaultUpdateName? deleteReturning? emitter filesSelectReturning? gql handleAuth? handleOperation? handlersSelectReturning? insertReturning? linkId? linksSelectReturning? local? minilinks ml namespace? Query remote? returning? secret? selectorsSelectReturning? selectReturning? silent ssl? Subscription table? token? treeSelectReturning? unsafe? unvertualizeId updateReturning? useCan useDeep useDeepId useDeepQuery useDeepSubscription useId useLink useLinks useLocalApply useLocalId useLocalQuery useLocalSubscription useMinilinksApply useMinilinksId useMinilinksQuery useMinilinksSubscription useQuery useSearch useSubscription valuesSelectReturning? ws? resolveDependency?

Methods

_findHandler _generateHooks _generateQuery _generateResult _queryTypesNamesSymbols _silent await can delete eval get getRemote guest id idLocal ids import insert isId isLink jwt login logout name nameLocal one Packager Packages reserve search searchQuery select serial serializeQuery serializeWhere stringify subscribe symbol symbolLocal Traveler update url value whoami

Constructors

constructor

Properties

apolloClient

apolloClient: IApolloClient<any>

OptionalcanSelectReturning

canSelectReturning?: string

client

client: IApolloClient<any>

deep

deep: DeepClientInstance<L>

DeepClient

DeepClient: typeof DeepClient = DeepClient

DeepContext

DeepContext: Context<DeepClient<Link<Id>>> = DeepContext

DeepProvider

DeepProvider: ((__namedParameters: {
    apolloClient?: IApolloClient<any>;
    children?: any;
    minilinks?: MinilinkCollection<MinilinksGeneratorOptions, Link<Id>>;
    namespace?: string;
    path?: string;
    secret?: string;
    ssl?: boolean;
    token?: string;
    ws?: boolean;
}) => Element) = DeepProvider

OptionaldefaultDeleteName

defaultDeleteName?: string

OptionaldefaultInsertName

defaultInsertName?: string

OptionaldefaultSelectName

defaultSelectName?: string

OptionaldefaultUpdateName

defaultUpdateName?: string

OptionaldeleteReturning

deleteReturning?: string

emitter

emitter: EventEmitter<DefaultEventMap>

OptionalfilesSelectReturning

filesSelectReturning?: string

gql

gql: typeof gql = gql

OptionalhandleAuth

handleAuth?: ((linkId?: Id, token?: string) => any)

OptionalhandleOperation

handleOperation?: ((operation: string, query?: any, value?: any, options?: any) => any)

OptionalhandlersSelectReturning

handlersSelectReturning?: string

OptionalinsertReturning

insertReturning?: string

OptionallinkId

linkId?: Id

OptionallinksSelectReturning

linksSelectReturning?: string

Optionallocal

local?: boolean

minilinks

minilinks: MinilinksResult<L>

ml

ml: MinilinksResult<L>

Optionalnamespace

namespace?: string

Query

Query: NamedExoticComponent<any>

Optionalremote

remote?: boolean

Optionalreturning

returning?: string

Optionalsecret

secret?: string

OptionalselectorsSelectReturning

selectorsSelectReturning?: string

OptionalselectReturning

selectReturning?: string

silent

silent: boolean

Optionalssl

ssl?: boolean

Subscription

Subscription: NamedExoticComponent<any>

Optionaltable

table?: string

Optionaltoken

token?: string

OptionaltreeSelectReturning

treeSelectReturning?: string

Optionalunsafe

unsafe?: any

unvertualizeId

unvertualizeId: ((id: Id) => Id)

OptionalupdateReturning

updateReturning?: string

useCan

useCan: ((objectId: Id | Id[], subjectId: Id | Id[], actionId: Id | Id[]) => {
    data: boolean | void;
    loading: boolean;
    refetch: (() => Promise<boolean>);
})

useDeep

useDeep: (() => DeepClient<Link<Id>>) = useDeep

useDeepId

useDeepId: ((start: QueryLink | DeepClientStartItem, ...path: DeepClientPathItem[]) => {
    data: Id;
    error?: any;
    loading: boolean;
})

useDeepQuery

useDeepQuery: (<Table, LL>(query: Exp<Table>, options?: Options<Table>) => {
    data?: LL[];
    error?: any;
    loading: boolean;
    refetch?: (() => Promise<any>);
})

useDeepSubscription

useDeepSubscription: (<Table, LL>(query: Exp<Table>, options?: Options<Table>) => UseDeepSubscriptionResult<LL>)

useId

useId: ((start: QueryLink | DeepClientStartItem, ...path: DeepClientPathItem[]) => {
    data: Id;
    error?: any;
    loading: boolean;
})

useLink

useLink: ((link: Id | Link<Id>) => MinilinksLink<Id>)

useLinks

useLinks: ((...links: (Id | Link<Id>)[]) => MinilinksLink<Id>[])

useLocalApply

useLocalApply: ((data: any, name: string) => {
    anomalies?: MinilinkError[];
    data: L[];
    errors?: MinilinkError[];
})

useLocalId

useLocalId: ((start: QueryLink | DeepClientStartItem, ...path: DeepClientPathItem[]) => void | Id)

useLocalQuery

useLocalQuery: ((query: Exp<"links">, options?: MinilinksQueryOptions<MinilinksQueryOptionAggregate>) => L[])

useLocalSubscription

useLocalSubscription: ((query: Exp<"links">, options?: MinilinksQueryOptions<MinilinksQueryOptionAggregate>) => L[])

useMinilinksApply

useMinilinksApply: ((data: any, name: string) => {
    anomalies?: MinilinkError[];
    data: L[];
    errors?: MinilinkError[];
})

useMinilinksId

useMinilinksId: ((start: QueryLink | DeepClientStartItem, ...path: DeepClientPathItem[]) => void | Id)

useMinilinksQuery

useMinilinksQuery: ((query: Exp<"links">, options?: MinilinksQueryOptions<MinilinksQueryOptionAggregate>) => L[])

useMinilinksSubscription

useMinilinksSubscription: ((query: Exp<"links">, options?: MinilinksQueryOptions<MinilinksQueryOptionAggregate>) => L[])

useQuery

useQuery: (<Table, LL>(query: Exp<Table>, options?: Options<Table>) => {
    data?: LL[];
    error?: any;
    loading: boolean;
    refetch?: (() => Promise<any>);
})

useSearch

useSearch: ((value: string, options?: DeepSearchOptions) => any)

useSubscription

useSubscription: (<Table, LL>(query: Exp<Table>, options?: Options<Table>) => UseDeepSubscriptionResult<LL>)

OptionalvaluesSelectReturning

valuesSelectReturning?: string

Optionalws

ws?: boolean

Static OptionalresolveDependency

resolveDependency?: ((path: string) => Promise<any>)

Methods

_findHandler

  • _findHandler(__namedParameters): Promise<void | Handler>

  • Parameters

    • __namedParameters: {
          context?: Id[];
          execution_provider_id?: number;
          handlerId?: Id;
          isolation_provider_id?: number;
      }
      • Optionalcontext?: Id[]
      • Optionalexecution_provider_id?: number
      • OptionalhandlerId?: Id
      • Optionalisolation_provider_id?: number

    Returns Promise<void | Handler>

_generateHooks

_generateQuery

_generateResult

  • _generateResult<TTable>(exp, options, data): any[] | Promise<any[]>

  • Type Parameters

    • TTable extends
          | "links"
          | "numbers"
          | "strings"
          | "objects"
          | "can"
          | "selectors"
          | "tree"
          | "handlers"

    Parameters

    Returns any[] | Promise<any[]>

_queryTypesNamesSymbols

  • _queryTypesNamesSymbols(): {
        return: {
            _contain: {
                relation: string;
                type_id: Id;
            };
            _symbol: {
                relation: string;
                type_id: Id;
            };
            _type: {
                relation: string;
                return: {
                    _contain: {
                        relation: string;
                        type_id: Id;
                    };
                    _symbol: {
                        relation: string;
                        type_id: Id;
                    };
                };
            };
        };
    }

  • Returns {
        return: {
            _contain: {
                relation: string;
                type_id: Id;
            };
            _symbol: {
                relation: string;
                type_id: Id;
            };
            _type: {
                relation: string;
                return: {
                    _contain: {
                        relation: string;
                        type_id: Id;
                    };
                    _symbol: {
                        relation: string;
                        type_id: Id;
                    };
                };
            };
        };
    }

    • return: {
          _contain: {
              relation: string;
              type_id: Id;
          };
          _symbol: {
              relation: string;
              type_id: Id;
          };
          _type: {
              relation: string;
              return: {
                  _contain: {
                      relation: string;
                      type_id: Id;
                  };
                  _symbol: {
                      relation: string;
                      type_id: Id;
                  };
              };
          };
      }
      • _contain: {
            relation: string;
            type_id: Id;
        }
        • relation: string
        • type_id: Id
      • _symbol: {
            relation: string;
            type_id: Id;
        }
        • relation: string
        • type_id: Id
      • _type: {
            relation: string;
            return: {
                _contain: {
                    relation: string;
                    type_id: Id;
                };
                _symbol: {
                    relation: string;
                    type_id: Id;
                };
            };
        }
        • relation: string
        • return: {
              _contain: {
                  relation: string;
                  type_id: Id;
              };
              _symbol: {
                  relation: string;
                  type_id: Id;
              };
          }
          • _contain: {
                relation: string;
                type_id: Id;
            }
            • relation: string
            • type_id: Id
          • _symbol: {
                relation: string;
                type_id: Id;
            }
            • relation: string
            • type_id: Id

_silent

await

  • await(id, options?): Promise<any>

  • Await for a promise

    Parameters

    • id: Id

      Id of a link which is processed by a handler

    • options: {
          results: boolean;
      } = ...

      An object with options for the await operation

      • results: boolean

    Returns Promise<any>

    A promise that resolves to the result of the awaited promise

    Example

    Await a promise of npm-packager

    Let us imagine you have published a package and want to programatically wait until it is published or failed to publish

    await deep.await(
      await deep.id('my-package-name')
    )

    In this case you will await all the promises for 'my-package-name' link

can

  • can(objectIds, subjectIds, actionIds, userIds?): Promise<boolean>

  • Checks whether subjectUds can perform actionIds on objectIds

    Parameters

    • objectIds: Id | Id[]

      A link id or an array of link ids to check whether the subjectUds can perform the actionIds on

    • subjectIds: Id | Id[]

      A link id or an array of link ids to check whether they can perform the actionIds on the objectIds

    • actionIds: Id | Id[]

      A link id or an array of link ids to check whether the subjectUds can perform on the objectIds

    • userIds: Id | Id[] = ...

      A link id or an array of link ids from which perspective the check is performed

    Returns Promise<boolean>

    A promise that resolves to a boolean value indicating whether the subjectUds can perform the actionIds on the objectIds

delete

  • delete<TTable>(exp, options?): Promise<DeepClientResult<{
        id: any;
    }[]>>

  • Deletes a value in the database. By default deletes a link in the links table

    Type Parameters

    • TTable extends
          | "links"
          | "numbers"
          | "strings"
          | "objects"

    Parameters

    • exp:
          | string
          | number
          | Id[]
          | (TTable extends "numbers"
              ? BoolExpValue<number>
              : TTable extends "strings"
                  ? BoolExpValue<string>
                  : TTable extends "objects"
                      ? BoolExpValue<object>
                      : TTable extends "can"
                          ? BoolExpCan
                          : TTable extends "selectors"
                              ? BoolExpSelector
                              : TTable extends "tree"
                                  ? BoolExpTree
                                  : TTable extends "handlers"
                                      ? BoolExpHandler
                                      : QueryLink)
    • Optionaloptions: WriteOptions<TTable>

      An object with options for the delete operation

    Returns Promise<DeepClientResult<{
        id: any;
    }[]>>

    A promise that resolves to the deleted object or an array of deleted objects with the fields configured by options.returning which is by default 'id'

    Example

    Delete by id

    await deep.delete({
      id: 888
    })

    In this case the link with id 888 will be deleted

    Delete by type_id

    await deep.delete({
      type_id: 888
    })

    In this case all the links with type_id 888 will be deleted

    Delete by from_id

    await deep.delete({
      from_id: 888
    })

    In this case all the links with from_id 888 will be deleted

    Delete by to_id

    await deep.delete({
      to_id: 888
    })

    In this case all the links with to_id 888 will be deleted

    Delete by string value

    await deep.delete({
      string: {
        value: {
          _eq: 'MyString'
        }
      }
    })

    In this case all the links with string value 'MyString' will be deleted

    Delete by number value

    await deep.delete({
      number: {
        value: {
          _eq: 888
        }
      }
    })

    In this case all the links with number value 888 will be deleted

    Delete by object value

    await deep.delete({
      object: {
        value: {
          _eq: {
            myFieldKey: "myFieldValue"
          }
        }
      }
    })

    In this case all the links with object value { myFieldName: "myFieldValue" } will be deleted

    Delete string value by link id

    await deep.delete({
      link_id: 888
    }, {
      table: 'strings'
    })

    In this case string value of a link with id 888 will be deleted

    Delete number value by link id

    await deep.delete({
      link_id: 888
    }, {
      table: 'numbers'
    })

    In this case number value of a link with id 888 will be deleted

    Delete object value by link id

    await deep.delete({
      link_id: 888
    }, {
      table: 'objects'
    })

    In this case object value of a link with id 888 will be deleted

eval

  • eval(__namedParameters): Promise<{
        data?: any;
        error?: any;
    }>

  • Parameters

    • __namedParameters: {
          context?: Id[];
          handlerId?: Id;
          input?: any;
          linkId?: Id;
          value?: string;
      }
      • Optionalcontext?: Id[]
      • OptionalhandlerId?: Id
      • Optionalinput?: any
      • OptionallinkId?: Id
      • Optionalvalue?: string

    Returns Promise<{
        data?: any;
        error?: any;
    }>

get

getRemote

guest

id

  • id(start, ...path): Promise<number>

  • Find id of a link by link name or id and contain values (names) as path items

    Parameters

    Returns Promise<number>

    A promise that resolves to the id of the link

    Example

    Get Core Package Link Id

    const corePackageLinkId = await deep.id("@deep-foundation/core")

    Get User Type Link Id From Core Package

    const userTypeLinkId = await deep.id("@deep-foundation/core", "User")

    Get the link called "My Nested Link Name" contained in the link called "My Link Name" contained the current user

    const myLinkId = await deep.id(deep.linkId, 'My Link Name', 'My Nested Link Name')

    Get Admin Link Id

    const adminLinkId = await deep.id("deep", "admin")

idLocal

  • idLocal(start, ...path): Id

  • Find id of a link from minilinks by link name or id and contain values (names) as path items

    Parameters

    Returns Id

    A promise that resolves to the id of the link

    Example

    Get Core Package Link Id

    const corePackageLinkId = deep.idLocal("@deep-foundation/core")

    Get User Type Link Id From Core Package

    const userTypeLinkId = deep.idLocal("@deep-foundation/core", "User")

    Get the link called "My Nested Link Name" contained in the link called "My Link Name" contained the current user

    const myLinkId = deep.idLocal(deep.linkId, 'My Link Name', 'My Nested Link Name')

    Get Admin Link Id

    const adminLinkId = deep.idLocal("deep", "admin")

ids

  • ids(...paths): Promise<any>

  • This function fetches the corresponding IDs from the Deep for each specified path.

    Parameters

    • Rest...paths: [DeepClientStartItem, ...DeepClientPathItem[]][]

      An array of [start, ...path] tuples. Each tuple specifies a path to a link, where 'start' is the package name or id and ...path further specifies the path to the id using Contain link values (names).

    Returns Promise<any>

    • Returns a Promise that resolves to an object. The object has keys corresponding to the package name or id of each path. The value for each package key is an object where keys are the items in the corresponding path, and the values are the IDs retrieved from the Deep.

    Async

    Function

    ids

    Throws

    Will throw an error if the id retrieval fails in this.id() function.

    Example

      const ids = await deep.ids([
        ['@deep-foundation/core', 'Package'], 
        ['@deep-foundation/core', 'PackageVersion']
      ]);

      // Outputs
      // {
      //   "@deep-foundation/core": {
      //     "Package": 2,
      //     "PackageVersion": 46
      //   }
      // }

import

  • import(path): Promise<any>

  • Imports from a library

    Parameters

    • path: string

      A path to import from

    Returns Promise<any>

    A promise that resolves to the imported value

    Remarks

    Is able to import CommoJS and ESModule libraries. This is the recommended way to import from libraries in deep handlers

    Example

    Async handler using import

    async ({deep}) => {
      const importResult = await deep.import("my-lib-name");
    }

insert

  • insert<TTable, LL>(objects, options?): Promise<DeepClientResult<{
        id: any;
    }[]>>

  • Inserts a value into the database. By default inserts a link to the links table

    Type Parameters

    • TTable extends
          | "links"
          | "numbers"
          | "strings"
          | "objects"
    • LL = L

    Parameters

    Returns Promise<DeepClientResult<{
        id: any;
    }[]>>

    A promise that resolves to the inserted object or an array of inserted objects with the fields configured by options.returning which is by default 'id'

    Remarks

    If a link already has value you should update its value, not insert

    Example

    Insert Type

    await deep.insert({
      type_id: await deep.id("@deep-foundation/core", "Type")
    })

    In this case instances of your type will not have from and to

    Insert Type from Package to User

    await deep.insert({
      type_id: await deep.id("@deep-foundation/core", "Type"),
      from_id: await deep.id("@deep-foundation/core", "Package"),
      to_id: await deep.id("@deep-foundation/core", "User")
    })

    In this case instances of your type will must go from instances of Package to instances of User

    Insert Type with from Any to Any

    await deep.insert({
      type_id: await deep.id("@deep-foundation/core", "Type"),
      from_id: await deep.id("@deep-foundation/core", "Any"),
      to_id: await deep.id("@deep-foundation/core", "Any")
    })

    In this case instances of your type may go from instances of any link to instances of any link without restrictions

    Insert Type with from Package to Any

    await deep.insert({
      type_id: await deep.id("@deep-foundation/core", "Type"),
      from_id: await deep.id("@deep-foundation/core", "Package"),
      to_id: await deep.id("@deep-foundation/core", "Any")
    })

    In this case instances of your type may go from instances of Package to instances of any link without restrictions

    Insert Type with from Any to Package

    await deep.insert({
      type_id: await deep.id("@deep-foundation/core", "Type"),
      from_id: await deep.id("@deep-foundation/core", "Any"),
      to_id: await deep.id("@deep-foundation/core", "Package")
    })

    In this case instances of your type may go from instances of any link without restrictions to instances of Package

    Insert string

    await deep.insert({
      link_id: 888,
      value: 'MyString'
    }, {
      table: 'strings'
    })

    Note: If a link already has value you should update its value, not insert

    Insert number

    await deep.insert({
      link_id: 888,
      value: 888
    }, {
      table: 'numbers'
    })

    Note: If a link already has value you should update its value, not insert

    Insert object

    await deep.insert({
      link_id: 888,
      value: {
        myFieldName: 'myFieldValue'
      }
    }, {
      table: 'objects'
    })

    Note: If a link already has value you should update its value, not insert

isId

isLink

jwt

login

  • login(options): Promise<DeepClientAuthResult>

  • Performs a login operation

    Parameters

    Returns Promise<DeepClientAuthResult>

    A promsie that resolves to the result of the login operation

    Example

    const apolloClient = generateApolloClient({
      path: NEXT_PUBLIC_GQL_PATH,
      ssl: true,
    });
    const unloginedDeep = new DeepClient({ apolloClient });
    const guestLoginResult = await unloginedDeep.guest();
    const guestDeep = new DeepClient({ deep: unloginedDeep, ...guestLoginResult });
    const adminLoginResult = await guestDeep.login({
      linkId: await guestDeep.id('deep', 'admin'),
    });
    const deep = new DeepClient({ deep: guestDeep, ...adminLoginResult });

logout

name

  • name(input): Promise<string>

  • Returns a name of a link input that is located in a value of a contain link pointing to the link input

    Parameters

    Returns Promise<string>

    Example

    const userTypeLinkId = await deep.id("@deep-foundation/core", "User");
    const userTypeLinkName = await deep.name(userTypeLinkId);

nameLocal

  • nameLocal(input): string

  • Returns a name of a link input that is located in a value of a contain link pointing to the link input according to links stored in minilinks

    Parameters

    Returns string

    Example

    const userTypeLinkId = await deep.id("@deep-foundation/core", "User");
    const userTypeLinkName = deep.nameLocal(userTypeLinkId);

    Note: "@deep-foundation/core" package, "User" link, Contain link pointing from "@deep-foundation/core" to "User" must be in minilinks

one

Packager

Packages

reserve

search

searchQuery

select

  • select<TTable, LL>(exp, options?): Promise<DeepClientResult<LL[]>>

  • Gets a value from the database. By default gets a link from the links table

    Type Parameters

    • TTable extends
          | "links"
          | "numbers"
          | "strings"
          | "objects"
          | "can"
          | "selectors"
          | "tree"
          | "handlers"
    • LL = L

    Parameters

    • exp: Exp<TTable>

      A filter expression to filter the objects to get

    • Optionaloptions: ReadOptions<TTable>

      An object with options for the select operation

    Returns Promise<DeepClientResult<LL[]>>

    A promise that resolves to the selected object or an array of selected objects with the fields configured by options.returning which is by default 'id'

    Example

    Select by id

    await deep.select({
      id: deep.linkId
    })

    Select by type_id

    await deep.select({
      type_id: {
        _id: ["@deep-foundation/core", "User"]
      }
    })

    Select by from_id

    await deep.select({
      from_id: deep.linkId
    })

    Select by to_id

    await deep.select({
      to_id: deep.linkId
    })

    Select by string value

    await deep.select({
      string: {
        value: {
          _eq: "MyString"
        }
      }
    })

    Select by number value

    await deep.select({
      number: {
        value: {
          _eq: 888
        }
      }
    })

    Select by object value

    await deep.select({
      object: {
        value: {
          _eq: {
            myFieldKey: "myFieldValue"
          }
        }
      }
    })

serial

serializeQuery

serializeWhere

stringify

subscribe

symbol

  • symbol(input): Promise<string>

  • Returns a symbol icon of a link input that is located in a value of a Symbol link to type of the link input

    Parameters

    Returns Promise<string>

    Example

    const userTypeLinkId = await deep.id("@deep-foundation/core", "User");
    const userTypeLinkSymbol = await deep.symbol(userTypeLinkId);

symbolLocal

  • symbolLocal(input): string

  • Returns a symbol icon of a link input that is located in a value of a Symbol link to type of the link input according to links stored in minilinks

    Parameters

    Returns string

    Example

    const userTypeLinkId = await deep.id("@deep-foundation/core", "User");
    const userTypeLinkSymbol = deep.symbolLocal(userTypeLinkId);

Traveler

update

  • update<TTable>(exp, value, options?): Promise<DeepClientResult<{
        id: any;
    }[]>>

  • Updates a value in the database. By default updates a link in the links table

    Type Parameters

    • TTable extends
          | "links"
          | "numbers"
          | "strings"
          | "objects"

    Parameters

    • exp:
          | string
          | number
          | Id[]
          | (TTable extends "numbers"
              ? BoolExpValue<number>
              : TTable extends "strings"
                  ? BoolExpValue<string>
                  : TTable extends "objects"
                      ? BoolExpValue<object>
                      : TTable extends "can"
                          ? BoolExpCan
                          : TTable extends "selectors"
                              ? BoolExpSelector
                              : TTable extends "tree"
                                  ? BoolExpTree
                                  : TTable extends "handlers"
                                      ? BoolExpHandler
                                      : QueryLink)
    • value: UpdateValue<TTable>

      A value to update the objects with

    • Optionaloptions: WriteOptions<TTable>

      An object with options for the update operation

    Returns Promise<DeepClientResult<{
        id: any;
    }[]>>

    A promise that resolves to the updated object or an array of updated objects with the fields configured by options.returning which is by default 'id'

    Example

    Update from by id

    await deep.update({
      id: 888
    }, {
      from_id: 1
    })

    In this case from_id will be updated to 1 for link with id 888

    Update to by id

    await deep.update({
      id: 888
    }, {
      to_id: 1
    })

    In this case to_id will be updated to 1 for link with id 888

    Update string value by link id

    await deep.update(
      {
        link_id: 888
      },
      {
        value: "MyStringValue"
      },
      {
        table: 'strings'
      }
    )

    In this case string value will be updated to "MyStringValue" for link with id 888

    Update number value by link id

    await deep.update(
      {
        link_id: 888
      },
      {
        value: 888
      },
      {
        table: 'numbers'
      }
    )

    In this case number value will be updated to 888 for link with id 888

    Update object value by link id

    await deep.update(
      {
        link_id: 888
      },
      {
        value: {
          myFieldName: "myFieldValue"
        }
      },
      {
        table: 'numbers'
      }
    )

    In this case number value will be updated to { myFieldName: "myFieldValue" } for link with id 888

url

value

whoami

Settings

Member Visibility

On This Page

Constructors
Properties
Methods
_findHandler_generateHooks_generateQuery_generateResult_queryTypesNamesSymbols_silentawaitcandeleteevalgetgetRemoteguestididLocalidsimportinsertisIdisLinkjwtloginlogoutnamenameLocalonePackagerPackagesreservesearchsearchQueryselectserialserializeQueryserializeWherestringifysubscribesymbolsymbolLocalTravelerupdateurlvaluewhoami
MMNEPVFCICPMFPCPTTAAATR