@relyio/sdk 0.16.0 → 0.18.0

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # @relyio/sdk
 
+## 0.18.0
+
+### Minor Changes
+
+- 87e12af: **A Function sends an Extension's Action without holding its key.** Declare the Actions a Function may send with the handles `relyio/extensions.ts` gives — `defineFunction({ actions: [webhook.post], … })` — and its `run` is handed `actions.<extension>.<action>(input)` for exactly those, its input and result typed by the Extension's own declaration; any other is a type error. A call is sent through RelyIO with the run's Environment: the run's code holds no Connection, no key and no webhook URL. In a Preview branch with no Preview Connection, nothing is sent: the call is Recorded on the run and answers the Action's sample. A refusal — an Extension with no Connection in Production, an input its fields refuse — throws an `ActionRefused` naming its `code` (`isActionRefused` narrows to it). A Function is never paused for an unconnected Extension; its call fails. Each call is keyed by the run and its order in it, so a run dispatched again sends nothing twice.
+- f9523f7: **Call a Function from your server.** `relyio.functions.checkout({ cartId })` runs the Function `checkout` that your key's Branch runs, on its Dataset, and answers its output. Call it with a secret key: a publishable key is refused `PublishableKeyRefusedError`, and a read-only key runs only a Function whose reach writes nothing. A run whose code threw, or that was ended at its CPU or memory limit, throws `FunctionRunFailedError`, and one still running after five minutes `FunctionRunTimedOutError`; each names the run (`runId`), whose record and console output you can read with `relyio functions logs`. A call waits as long as the service does and is never retried.
+- ebbfffe: **A test run from the Function editor says so.** A run the Function editor's Test run starts has `run.wayIn` `'editor'` and `run.caller` `user:<userId>`, and always runs in that person's own Preview branch: `run.environment` is `'preview'`, it reads Production's Records, and what it writes lands as copies there.
+- 6177f0f: **A Function can store a File, and run in a Container.** In a Function's `run`, `records.file(bytes, { name })` answers a `FunctionFile` to set as the value of a File field in a create, an update or a batch — `records.order.update(id, { invoice: records.file(pdf, { name: 'invoice-1001.pdf' }) })`. The media type is read off the name's extension unless you pass `type`. The bytes are stored privately under the Record, as an upload's are, and a run retried after its write committed names the same File rather than storing it twice. A Function declaring `runtime: 'container'` with `container: { size }` now runs, in RelyIO's own Node 24 image with Chromium and fonts, for up to its `limits.duration` (15 minutes unless it declares up to 60); its requests leave only through the hosts its reach declares, as an Isolate's do.
+- b6a45d3: **Records inside a Function, all or none, written once.** In a Function's `run`, `records.<type>` holds exactly the Record types its reach names: `get`, `list` and `count` for a type it reads, and `create`, `update`, `delete`, `increment` and `decrement` for one it writes, each sent as a batch of one. `records.batch(b => …)` collects operations synchronously — awaiting inside the callback is a type error — sends them as one atomic batch and answers the Records it `created`. A refusal throws a `BatchRefused` naming the `operation`, the `code` and the `field` (`isBatchRefused` narrows to it), and nothing of the batch is written. Every batch is keyed by the run, so a run dispatched again writes nothing twice; pass `idempotencyKey` to `relyio.functions.checkout(input, { idempotencyKey })` and the same key sent again writes nothing the first call wrote. The `upload` the capability object's types named is gone until a Function can store a File.
+- 84df9fe: **A Function answers its own route.** A Function declaring `route: { method, path }` answers at `https://<projectId>.fn.relyio.com/<path>` — a Branch's at `https://<projectId>--<branchId>.fn.relyio.com/<path>` — with its input read from the JSON or form body and the path's `:params`, checked against its `input` fields. `request` on the capability object is the caller's request. Return `respond({ status, headers, body })` from `@relyio/sdk/functions` to answer with a status, headers and body of the Function's own — a redirect after a form post — or any other output to answer it as JSON. `route.public` takes the route without a key, limited to 60 calls a minute per address unless `perIp` says otherwise, and behind Turnstile when `turnstile` names the Secret holding its secret key; `route.cors` lists the browser origins allowed to call it.
+- bb231a8: **Scheduled and Automation runs know what started them.** A Function declaring `schedule: { cron, timezone }` runs once at each firing on Production — never on a Preview branch — and after an outage only the latest missed firing runs. In `run`, `run.wayIn` is `'schedule'` and `run.event` is `{ type: 'function.schedule', scheduledFor }`, the UTC instant the firing was for; a run an Automation step dispatches carries its event there too. Such a run is retried under the same `run.id`, with `run.attempt` counting, so a Records batch it already committed answers as it did and writes nothing twice. `run.caller` names the task, `task:<taskId>`.
+- 8ba3308: **A locale's publication status is `draft` or `published`; `archived` is gone from `localeStatus` and `availableLocales[].status`.** Nothing could archive a single locale — archiving is the entry's act, read from `_metadata.status` — so no read ever reported it. `buildLanguageSwitcher` loses the `showArchived` option and each option's `hasContent`, which only ever said whether a locale was archived and so was always `true`: delete `showArchived` from its calls and stop reading `hasContent`. Code that compared a locale's status to `'archived'` now fails to compile; delete that branch.
+- f422624: **Records: app data your server writes, typed by your schema.** Declare a Record type with `defineRecordType` beside your content types — orders, stock, reviews, carts — with `fields.counter`, `fields.sequence` and `fields.file` among its fields, unique sets, and `expireAfter` for data that should go once it is left alone. `relyio.records(type)` creates, lists (filters, a sort, a count and facets), gets, updates against the revision it read (`If-Match`), deletes and uploads a File, typed by the schema: an update takes no Counter and no Sequence (`RecordUpdateFieldsOf`), and a read answers the fields with `RecordMetadata`. `relyio.records.batch([...])` runs creates, updates, deletes and counter moves across Record types in one transaction, all or none, under an `Idempotency-Key`; `refusedOperationOf(error)` names the operation refused. A content type keeps rollups over the Records that reference its entries (`rollup.count`, `sum`, `average`, `min`, `max`), read beside its fields. A Record route needs a secret key: a publishable key is refused `PublishableKeyRefusedError`.
+- e5a5f94: **A field declared `unique: true` is unique, and a clash says which field, locale and entry in `error.context.blockage`.** A write whose value another entry of the content type already holds in a `unique` field — in that locale, for a localized field — is refused with a `ResourceConflictError` whose `context.blockage` is `{ kind: 'value-taken', facts: { path, code: 'VALUE_TAKEN', locale, value, entryId } }`: the field's path (with its locale for a localized field), the locale whose claim collided, the value, and the id of the entry that holds it. A slug keeps its `slug-taken` blockage. Before, `unique` was accepted on every field and enforced on none but the slug.
+
+## 0.17.0
+
+### Minor Changes
+
+- fb6625a: `content(type).create()` and `update()` answer `_metadata.warnings`: each reference the content type declares `weak` that the write published while the entry it points at is unpublished, as `{ path, code: 'REFERENCE_NOT_PUBLISHED', message }`. Always present, `[]` when there are none; the write is never refused for them. `create()` now returns `CreatedContent<T>`, the entry with that list.
+
+  `singleton(key).update()`, `settings(group).update()` and `settings(group).reset()` answer the same `_metadata.warnings`, beside the `_metadata.brokenLinks` they already carried; they now return `WrittenSingleton<T>` and `WrittenSettingsGroup<T>`. A `batch()` item for any write but a delete carries the list under `data._metadata.warnings` as well.
+
 ## 0.16.0
 
 ### Minor Changes

package/dist/automations/index.cjs

@@ -0,0 +1,70 @@
+'use strict';
+
+var chunkLSI26ZN2_cjs = require('../chunk-LSI26ZN2.cjs');
+var chunkZAMAR3X2_cjs = require('../chunk-ZAMAR3X2.cjs');
+require('../chunk-L6DXCKVQ.cjs');
+
+
+
+Object.defineProperty(exports, "and", {
+  enumerable: true,
+  get: function () { return chunkLSI26ZN2_cjs.and; }
+});
+Object.defineProperty(exports, "anyEntry", {
+  enumerable: true,
+  get: function () { return chunkLSI26ZN2_cjs.anyEntry; }
+});
+Object.defineProperty(exports, "automations", {
+  enumerable: true,
+  get: function () { return chunkLSI26ZN2_cjs.automations; }
+});
+Object.defineProperty(exports, "defineAutomation", {
+  enumerable: true,
+  get: function () { return chunkLSI26ZN2_cjs.defineAutomation; }
+});
+Object.defineProperty(exports, "entries", {
+  enumerable: true,
+  get: function () { return chunkLSI26ZN2_cjs.entries; }
+});
+Object.defineProperty(exports, "extensionTrigger", {
+  enumerable: true,
+  get: function () { return chunkLSI26ZN2_cjs.extensionTrigger; }
+});
+Object.defineProperty(exports, "isAutomationFile", {
+  enumerable: true,
+  get: function () { return chunkLSI26ZN2_cjs.isAutomationFile; }
+});
+Object.defineProperty(exports, "not", {
+  enumerable: true,
+  get: function () { return chunkLSI26ZN2_cjs.not; }
+});
+Object.defineProperty(exports, "on", {
+  enumerable: true,
+  get: function () { return chunkLSI26ZN2_cjs.on; }
+});
+Object.defineProperty(exports, "or", {
+  enumerable: true,
+  get: function () { return chunkLSI26ZN2_cjs.or; }
+});
+Object.defineProperty(exports, "records", {
+  enumerable: true,
+  get: function () { return chunkLSI26ZN2_cjs.records; }
+});
+Object.defineProperty(exports, "resolveAutomation", {
+  enumerable: true,
+  get: function () { return chunkLSI26ZN2_cjs.resolveAutomation; }
+});
+Object.defineProperty(exports, "schedule", {
+  enumerable: true,
+  get: function () { return chunkLSI26ZN2_cjs.schedule; }
+});
+Object.defineProperty(exports, "tpl", {
+  enumerable: true,
+  get: function () { return chunkLSI26ZN2_cjs.tpl; }
+});
+Object.defineProperty(exports, "fields", {
+  enumerable: true,
+  get: function () { return chunkZAMAR3X2_cjs.fields; }
+});
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map