@relyio/sdk 0.17.0 → 0.19.0

package/CHANGELOG.md

@@ -1,5 +1,40 @@
 # @relyio/sdk
 
+## 0.19.0
+
+### Minor Changes
+
+- 0c154b3: **Declare who may read and write each type.** A Record type takes an Owner field, `fields.owner()`, which RelyIO sets from the signed-in End user's token, and `endUsers` names its Policies — `read`, `create`, `update` (with the `fields` an End user may set) and `delete`, each `'owner'`, `'signedIn'`, `'anyone'` (for a read) or a condition built with `conditionRoot('record' | 'claims')`, `and`, `or` and `not`. `perUser.writesPerMinute` caps one End user's writes, and `onOwnerDeleted: 'delete' | 'keep'` says what becomes of their Records when their identity provider deletes them. A content type's `endUsers.read: { when, otherwise }` Gates it: an entry `when` holds of is served whole, any other as its `otherwise` fields with `_gated: true`. The rule types are exported from `@relyio/sdk/schema` as `PolicyRule`, `NamedPolicyRule`, `WriteRule`, `FieldsWriteRule`, `RecordWriteRule`, `RecordTypeEndUsers` and `OwnerDeletedAction`.
+
+  **Private fields.** `private: true` on a field keeps it from every publishable-key read and every End user's, whatever key they come with; your server and your Functions still read it.
+
+  **Clerk's users.** With Clerk in `relyio/extensions.ts`, `clerk.userRef()` declares a reference to a `clerkUser` — the Record RelyIO keeps for each of your Clerk users — and a signed-in End user reads their own `clerkUser`, by its list, by its id, or through an Owner field's include.
+
+  **Refusals you can catch.** A refused End user token is `EndUserTokenInvalidError`, with `reason` (`expired`, `wrong-audience`, `missing`, …). `PublishableKeyRefusedError` now says how to fix it: send the End user's token, declare `endUsers` on the Function, or call from your server. A unique value an End user's write collides with names no `recordId`: it may be a Record they cannot read.
+
+- 6acd363: **Every request carries the signed-in End user's token.** Hand the client your identity provider's token function once — `createClient({ apiKey, getToken })`, Clerk's `getToken` or your own — and each request asks it then: a token is sent as `X-RelyIO-End-User` beside the key, and `null` (or a blank string) sends nothing, so the request is the key's alone. It is asked once per call, so every retry sends the token the first attempt sent; a function that throws rejects the call with nothing sent. It works with a publishable key in a browser and a secret key on a server. `client.with({ getToken })` makes a client that asks its own function in place of its parent's, and `updateConfig({ getToken: null })` stops sending one. A token the API cannot verify is refused `END_USER_TOKEN_INVALID` (401).
+
+  **Claims are typed from `relyio/extensions.ts`.** `ClaimsOf<typeof extensions>` (`@relyio/sdk/extensions`) is an object with one optional key per Claim the identity Extension's `claims` setting names — `oidc: { claims: 'plan, role' }` is `{ plan?: unknown; role?: unknown }` — so `conditionRoot<ClaimsOf<typeof extensions>>('claims').plan.eq('paid')` compiles and a misspelt Claim does not. A setting is text, so a Claim's value is `unknown`.
+
+- 10d761f: **A browser may call a Function that says so.** `defineFunction({ endUsers: 'required', … })` lets a publishable key call it through `relyio.functions.<name>(input)` for a signed-in End user — the call carries their token (`getToken`), and without one it is refused `END_USER_TOKEN_INVALID` (401, reason `missing`); `endUsers: 'optional'` lets it call with or without one. A Function that declares neither is still refused to a publishable key (`PUBLISHABLE_KEY_REFUSED`). The run is bound by the Function's own reach either way — a checkout takes stock the shopper could never write — and the plan names a new or widened `endUsers`.
+
+  **`run.endUser` names who called.** Any call carrying a verified token — with any key, or to a Public route sent one — hands the run `run.endUser`: `{ subject, claims }`, the subject an Owner field stores, and the Claims your `relyio/extensions.ts` declares. Type them by registering it: `declare module '@relyio/sdk' { interface Register { extensions: typeof extensions } }`. A Record the run creates with no owner named is that End user's; name one to set it yourself.
+
+## 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

package/dist/automations/index.cjs

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