@lowdefy/docs-content 0.0.0-experimental-20260710073520

package/content/operators/_module.md

@@ -0,0 +1,340 @@
+# _module
+
+```
+_module.var: (key: string): any
+_module.pageId: (pageId: string): string
+_module.pageId: (arguments: { id: string, module: string }): string
+_module.connectionId: (connectionId: string): string
+_module.connectionId: (arguments: { id: string, module: string }): string
+_module.endpointId: (endpointId: string): string
+_module.endpointId: (arguments: { id: string, module: string }): string
+_module.notificationId: (notificationId: string): string
+_module.notificationId: (arguments: { id: string, module: string }): string
+_module.id: (true): string
+_module.id: (arguments: { module: string }): string
+```
+
+The `_module` operator family provides access to module-scoped values during the build. `_module.var` and the string forms of the ID operators only make sense inside module config files — the build throws a clear error if you use them at the app level.
+
+The object form of `_module.pageId`, `_module.connectionId`, `_module.endpointId`, `_module.notificationId`, and `_module.id` also works at the app level, resolving by entry ID instead of a dependency name — useful for linking, calling, or labelling a specific module instance from app-level config without hardcoding the scoped ID. See each method below for an app-level example.
+
+All `_module` operators resolve during the walker pass — the same phase as `_var` and `_ref`. Inside module files, they work at any depth.
+
+See [Modules](/modules) for an overview of the module system.
+
+# Operator methods:
+
+## _module.var
+
+```
+(key: string): any
+```
+
+The `_module.var` operator reads a value from the module entry's `vars`. It returns the consumer value passed in `lowdefy.yaml` if one was provided, otherwise it resolves the manifest default on read. If neither is provided (no consumer value, no declared default), the operator returns `null`.
+
+Unlike `_var`, which requires threading variables through each `_ref`, `_module.var` works at any depth within module files. It accesses the same vars regardless of `_ref` nesting.
+
+Defaults are declared in `module.lowdefy.yaml` and resolve on read. Defaults are expressions — they can be literals, `_ref`s, `_module.var` references to other vars, or any `_build.*` tree. See [Writing Modules → Dynamic Defaults](/module-authoring#dynamic-defaults) for patterns.
+
+Vars with `properties` merge at the property level — only consumer-provided keys override the declared defaults, and missing properties resolve their own defaults independently.
+
+#### Arguments
+
+###### string
+The key in the module entry's `vars` object. Dot notation is supported for nested access (e.g., `theme.colors.primary`).
+
+#### Examples
+
+###### Simple string access:
+```yaml
+title:
+  _module.var: title
+```
+If the app provides `vars: { title: "Welcome" }`, returns `"Welcome"`.
+
+###### Nested path access:
+```yaml
+primary_color:
+  _module.var: theme.colors.primary
+```
+Accesses nested values using dot notation. If the module manifest declares defaults via `properties`, unset values resolve to their defaults.
+
+## _module.pageId
+
+```
+(pageId: string): string
+(arguments: { id: string, module: string }): string
+```
+
+Resolves a page ID to its fully scoped ID. The string form references the current module's own pages and only works inside module content.
+
+The object form references a target by entry ID. Inside module content, `module` is the abstract dependency name declared in `module.lowdefy.yaml`. At the app level, `module` is the concrete module entry ID from `lowdefy.yaml` — useful when an app-level page needs to link to a specific module instance.
+
+#### Arguments
+
+###### string
+The module-local page ID (as declared in the module's page definition).
+
+###### object
+  - `id: string`: The page ID in the target module.
+  - `module: string`: The abstract dependency name (in module content) or the module entry ID (in app-level config).
+
+#### Examples
+
+###### Link to a sibling page:
+```yaml
+- id: view_details
+  type: Link
+  params:
+    pageId:
+      _module.pageId: user-edit
+```
+In a module entry with `id: team-users`, resolves to `team-users/user-edit`.
+
+###### Link to a page in another module:
+```yaml
+- id: view_contact
+  type: Link
+  params:
+    pageId:
+      _module.pageId:
+        id: contact-detail
+        module: contacts
+```
+If the `contacts` dependency is wired to an entry with `id: contacts`, resolves to `contacts/contact-detail`.
+
+###### Link from an app page to a module page:
+```yaml
+# lowdefy.yaml (app level)
+pages:
+  - id: home
+    blocks:
+      - id: view_team
+        type: Link
+        params:
+          pageId:
+            _module.pageId:
+              id: users-list
+              module: team-users
+```
+At the app level, `module` is the module entry ID. The build resolves this to `team-users/users-list` regardless of where the entry lives in your config.
+
+## _module.connectionId
+
+```
+(connectionId: string): string
+(arguments: { id: string, module: string }): string
+```
+
+Resolves a connection ID to its scoped or remapped ID. The string form references the current module's connections and only works inside module content.
+
+The object form references a target by entry ID. Inside module content, `module` is the abstract dependency name declared in `module.lowdefy.yaml`. At the app level, `module` is the concrete module entry ID from `lowdefy.yaml` — useful when an app-level request needs to reach a specific module instance's connection.
+
+#### Arguments
+
+###### string
+The module-local connection ID (as declared in the module's connection definition).
+
+###### object
+  - `id: string`: The connection ID in the target module.
+  - `module: string`: The abstract dependency name (in module content) or the module entry ID (in app-level config).
+
+#### Examples
+
+###### Reference a module connection:
+```yaml
+connectionId:
+  _module.connectionId: users-db
+```
+In a module entry with `id: team-users`, resolves to `team-users/users-db`.
+
+If the app remaps the connection (`connections: { users-db: my-app-mongodb }`), resolves to `my-app-mongodb` instead.
+
+###### Reference a connection in another module:
+```yaml
+connectionId:
+  _module.connectionId:
+    id: contacts-db
+    module: contacts
+```
+Resolves to the target module's scoped or remapped connection ID.
+
+###### Reference a module connection from an app request:
+```yaml
+# lowdefy.yaml (app level)
+api:
+  - id: get_team_users
+    type: Request
+    connectionId:
+      _module.connectionId:
+        id: users-db
+        module: team-users
+```
+At the app level, `module` is the module entry ID. The build resolves this to the target module's scoped or remapped connection ID.
+
+## _module.endpointId
+
+```
+(endpointId: string): string
+(arguments: { id: string, module: string }): string
+```
+
+Resolves an API endpoint ID to its fully scoped ID. The string form references the current module's endpoints and only works inside module content.
+
+The object form references a target by entry ID. Inside module content, `module` is the abstract dependency name declared in `module.lowdefy.yaml`. At the app level, `module` is the concrete module entry ID from `lowdefy.yaml` — useful when an app-level page needs to call a specific module instance's API.
+
+#### Arguments
+
+###### string
+The module-local endpoint ID (as declared in the module's API definition).
+
+###### object
+  - `id: string`: The endpoint ID in the target module.
+  - `module: string`: The abstract dependency name (in module content) or the module entry ID (in app-level config).
+
+#### Examples
+
+###### Call a module API endpoint:
+```yaml
+- id: call_invite
+  type: CallAPI
+  params:
+    endpointId:
+      _module.endpointId: invite-user
+```
+In a module entry with `id: team-users`, resolves to `team-users/invite-user`.
+
+###### Call an API in another module:
+```yaml
+- id: log_event
+  type: CallAPI
+  params:
+    endpointId:
+      _module.endpointId:
+        id: log-event
+        module: events
+```
+Resolves to the target module's scoped endpoint ID.
+
+###### Call a module API endpoint from an app page:
+```yaml
+# lowdefy.yaml (app level)
+pages:
+  - id: dashboard
+    events:
+      onClick:
+        - id: log_event
+          type: CallAPI
+          params:
+            endpointId:
+              _module.endpointId:
+                id: log-event
+                module: events
+```
+At the app level, `module` is the module entry ID. The build resolves this to `events/log-event`.
+
+## _module.notificationId
+
+```
+(notificationId: string): string
+(arguments: { id: string, module: string }): string
+```
+
+Resolves a notification ID to its fully scoped ID. The string form references the current module's notifications and only works inside module content.
+
+The object form references a target by entry ID. Inside module content, `module` is the abstract dependency name declared in `module.lowdefy.yaml`. At the app level, `module` is the concrete module entry ID from `lowdefy.yaml` — useful when app-level config dispatches a notification whose template a module ships.
+
+#### Arguments
+
+###### string
+The module-local notification ID (as declared in the module's `notifications:` section).
+
+###### object
+  - `id: string`: The notification ID in the target module.
+  - `module: string`: The abstract dependency name (in module content) or the module entry ID (in app-level config).
+
+#### Examples
+
+###### Render the module's own notification:
+```yaml
+- id: render
+  type: RenderNotification
+  properties:
+    notificationId:
+      _module.notificationId: invite-user
+    data:
+      contact:
+        _payload: contact
+```
+In a module entry with `id: user-admin`, resolves to `user-admin/invite-user`.
+
+###### Dispatch with a scoped notification id from an app page:
+```yaml
+# lowdefy.yaml (app level)
+params:
+  endpointId:
+    _module.endpointId:
+      id: dispatch-notifications
+      module: notifications
+  payload:
+    notification_id:
+      _module.notificationId:
+        id: invite-user
+        module: user-admin
+```
+At the app level, `module` is the module entry ID. The build resolves this to `user-admin/invite-user`.
+
+## _module.id
+
+```
+(true): string
+(arguments: { module: string }): string
+```
+
+Returns the raw module entry ID. The `true` form returns the current module's entry ID and only works inside module content.
+
+The object form returns the entry ID of a referenced module. Inside module content, `module` is the abstract dependency name declared in `module.lowdefy.yaml`. At the app level, `module` is the concrete module entry ID from `lowdefy.yaml` — useful for templates that need a module entry ID without hardcoding it.
+
+#### Arguments
+
+###### boolean
+Pass `true` to return the current module entry ID.
+
+###### object
+  - `module: string`: The abstract dependency name (in module content) or the module entry ID (in app-level config).
+
+#### Examples
+
+###### Use in a label:
+```yaml
+label:
+  _string.concat:
+    - _module.id: true
+    - " - User Admin"
+```
+In a module entry with `id: team-users`, returns `"team-users - User Admin"`.
+
+###### Get a dependency's entry ID:
+```yaml
+contactsEntry:
+  _module.id:
+    module: contacts
+```
+Returns the concrete entry ID that the `contacts` dependency is wired to.
+
+###### Reference a module entry ID at the app level:
+```yaml
+# lowdefy.yaml (app level)
+pages:
+  - id: home
+    blocks:
+      - id: status_label
+        type: Title
+        properties:
+          content:
+            _string.concat:
+              - 'Active module: '
+              - _module.id:
+                  module: team-users
+```
+At the app level, `module` is the module entry ID. Returns the entry ID verbatim — useful inside `_build.*` expressions or templates that need the entry name.

package/content/operators/_mql.md

@@ -0,0 +1,95 @@
+# _mql
+
+The `_mql` operator uses the [`mingo`](https://www.npmjs.com/package/mingo) package to evaluate MongoDB query language statements as an operator.
+
+# Operator methods:
+
+## _mql.aggregate
+
+```
+({on: object[], pipeline: object[]}): object[]
+([on: object[], pipeline: object[]]): object[]
+```
+
+The `_mql.aggregate` method runs a MongoDB aggregation pipeline on an input array.
+
+#### Arguments
+
+###### object
+  - `on: object[]`: The data array on which to run the pipeline. It should be an array of objects.
+  - `pipeline: object[]`: A MongoDB aggregation pipeline definition.
+
+#### Examples
+
+###### Transform request results:
+```yaml
+_mql.aggregate:
+  pipeline:
+    - $match:
+        age:
+          $gte: 18
+    - $addFields:
+        averageScore:
+          $avg:
+            - $score1
+            - $score2
+  on:
+    _request: my_request
+```
+
+## _mql.expr
+
+```
+({on: object, expr: any}): any
+([on: object, expr: any]): any
+```
+
+The `_mql.expr` method evaluates a MongoDB aggregation pipeline operator expression. This is any statement that could be written in a `$project` stage.
+
+#### Arguments
+
+###### object
+  - `on: object`: An object to take as input for the expression.
+  - `expr: object`: A MongoDB aggregation expression.
+
+#### Examples
+
+###### Calculate an average of three inputs:
+```yaml
+_mql.expr:
+  expr:
+    $avg:
+      - $input1
+      - $input2
+      - $input3
+  on:
+    _state: true
+```
+
+## _mql.test
+
+```
+({on: object, test: object}): boolean
+([on: object, test: object]): boolean
+```
+
+The `_mql.test` method tests if a object matches a MongoDB filter/query expression.
+
+#### Arguments
+
+###### object
+  - `on: object`: The object to be tested.
+  - `test: object`: A MongoDB filter/query expression.
+
+#### Examples
+
+###### Test if a number input is greater than 100:
+```yaml
+_mql.test:
+  test:
+    number_input:
+      $gte: 18
+  on:
+    number_input:
+      _state: number_input
+```

package/content/operators/_ne.md

@@ -0,0 +1,62 @@
+# _ne
+
+```
+([value1: any, value2: any]): boolean
+```
+
+The `_ne` operator tests if two values are not equal. It takes an array of two values to test.
+
+> The `_ne` won't do a deep comparison.
+
+> This operator can be used as a [`_build`](/_build) operator method.
+
+#### Arguments
+
+###### array
+An array of two values to compare.
+
+#### Examples
+
+###### Two non-equal strings:
+
+```yaml
+_ne:
+  - "Hello"
+  - "Hello you"
+```
+Returns: `true`
+
+###### Two equal strings:
+
+```yaml
+_ne:
+  - "Hello"
+  - "Hello"
+```
+Returns: `false`
+
+###### Two numbers:
+```yaml
+_ne:
+  - _sum:
+      - 3
+      - 4
+  - 8
+```
+Returns: `true`
+
+###### Arrays are not compared deeply:
+```yaml
+_ne:
+  - [1,2,3]
+  - [1,2,3]
+```
+Returns: `true`
+
+###### Values from "getter" operators are copies and not equal:
+```yaml
+_ne:
+  - _state: my_object
+  - _state: my_object
+```
+Returns: `true`

package/content/operators/_not.md

@@ -0,0 +1,33 @@
+# _not
+
+```
+(value: any): boolean
+```
+
+The `_not` operator returns the logical negation of the input. If the value is not a boolean, it will be converted to a boolean using javascript [truthy](https://developer.mozilla.org/en-US/docs/Glossary/Truthy) and [falsy](https://developer.mozilla.org/en-US/docs/Glossary/Falsy) rules.
+
+> This operator can be used as a [`_build`](/_build) operator method.
+
+#### Arguments
+
+###### any
+
+#### Examples
+
+###### Not `true` is `false`:
+```yaml
+_not: true
+```
+Returns: `false`
+
+###### Return `true` for a falsy value:
+```yaml
+_not: null
+```
+Returns: `true`
+
+###### Return `false` for a truthy value:
+```yaml
+_not: 100
+```
+Returns: `false`

package/content/operators/_number.md

@@ -0,0 +1,159 @@
+# _number
+
+The `_number` operator can be used to run javascript [`Number`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number) methods.
+
+> This operator can be used as a [`_build`](/_build) operator method.
+
+# Operator methods:
+
+## _number.EPSILON
+
+```
+(void): number
+```
+
+The `_number.EPSILON` property represents the smallest interval between two representable numbers.. [See MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/EPSILON) for more details and examples.
+
+## _number.MAX_SAFE_INTEGER
+
+```
+(void): number
+```
+
+The `_number.MAX_SAFE_INTEGER` property represents the maximum safe integer in JavaScript (2^53 - 1). [See MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER) for more details and examples.
+
+## _number.MAX_VALUE
+
+```
+(void): number
+```
+
+The `_number.MAX_VALUE` property represents the largest positive representable number. [See MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_VALUE) for more details and examples.
+
+## _number.MIN_SAFE_INTEGER
+
+```
+(void): number
+```
+
+The `_number.MIN_SAFE_INTEGER` property represents the minimum safe integer in JavaScript (-(2^53 - 1)). [See MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MIN_SAFE_INTEGER) for more details and examples.
+
+## _number.MIN_VALUE
+
+```
+(void): number
+```
+
+The `_number.MIN_VALUE` property represents the smallest positive representable number — that is, the positive number closest to zero (without actually being zero). [See MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MIN_VALUE) for more details and examples.
+
+## _number.NaN
+
+```
+(void): number
+```
+
+The `_number.NaN` property represents the special "Not a Number" value. [See MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/NaN) for more details and examples.
+
+## _number.NEGATIVE_INFINITY
+
+```
+(void): number
+```
+
+The `_number.NEGATIVE_INFINITY` property represents negative infinity. Returned on overflow. [See MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/NEGATIVE_INFINITY) for more details and examples.
+
+## _number.POSITIVE_INFINITY
+
+```
+(void): number
+```
+
+The `_number.POSITIVE_INFINITY` property represents positive infinity. [See MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/POSITIVE_INFINITY) for more details and examples.
+
+## _number.isFinite
+
+```
+(void): number
+```
+
+The `_number.isFinite` method is used to determine whether the passed value is a finite number. [See MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isFinite) for more details and examples.
+
+## _number.isInteger
+
+```
+(void): number
+```
+
+The `_number.isInteger` method is used to determine whether the passed value is an integer. [See MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger) for more details and examples.
+
+## _number.isNaN
+
+```
+(void): number
+```
+
+The `_number.isNaN` method is used to determine whether the passed value is NaN. [See MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isNaN) for more details and examples.
+
+## _number.isSafeInteger
+
+```
+(void): number
+```
+
+The `_number.isSafeInteger` method is used to determine whether the passed value is a safe integer (number between -(2^53 - 1) and 2^53 - 1). [See MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger) for more details and examples.
+
+## _number.parseFloat
+
+```
+(void): number
+```
+
+The `_number.parseFloat` method parses an argument and returns a floating point number. If a number cannot be parsed from the argument, it returns NaN. [See MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/parseFloat) for more details and examples.
+
+## _number.parseInt
+
+```
+(void): number
+```
+
+The `_number.parseInt` method parses a string argument and returns an integer of the specified radix or base. If a number cannot be parsed from the argument, it returns NaN. [See MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/parseInt) for more details and examples.
+
+## _number.toExponential
+
+```
+(void): number
+```
+
+The `_number.toExponential` method returns a string representing the Number object in exponential notation. [See MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toExponential) for more details and examples.
+
+## _number.toFixed
+
+```
+(void): number
+```
+
+The `_number.toFixed` method formats a number using fixed-point notation. [See MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toFixed) for more details and examples.
+
+## _number.toLocaleString
+
+```
+(void): number
+```
+
+The `_number.toLocaleString` method returns a string with a language-sensitive representation of this number. [See MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toLocaleString) for more details and examples.
+
+## _number.toPrecision
+
+```
+(void): number
+```
+
+The `_number.toPrecision` method returns a string representing the Number object to the specified precision. [See MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toPrecision) for more details and examples.
+
+## _number.toString
+
+```
+(void): number
+```
+
+The `_number.toString` method returns a string representing the specified Number object. [See MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toString) for more details and examples.