@flaredev/core 0.8.0 → 0.9.0

package/dist/{chunk-JYWV3AF6.js → chunk-AAXNSIZG.js}

@@ -15,6 +15,7 @@ var STRING_FORMATS = [
   "currency",
   "postcode"
 ];
+var TEXT_FORMATS = ["markdown"];
 var NUMBER_FORMATS = ["money", "percent", "rating"];
 var FILE_CATEGORIES = {
   // For a field that holds whatever someone has: a drive, an attachment, a backup.
@@ -72,6 +73,12 @@ var field = {
   radio: (values, options) => build("enum", options, { options: values, widget: "radio" }),
   /** Any number of a list, picked with checkboxes. Stored as a JSON array. */
   multiselect: (values, options) => build("multiselect", options, { options: values, sortable: false }),
+  /** Free-text labels, as many as wanted. Stored as a JSON array. */
+  tags: (options) => build("tags", options, { sortable: false, searchable: false }),
+  /** Anything not table-shaped: a settings blob, a payload, metadata. Stored as JSON. */
+  json: (options) => build("json", options, { list: false, sortable: false, searchable: false }),
+  /** Long text written as Markdown: a split editor, rendered where it is shown. */
+  markdown: (options) => build("text", options, { format: "markdown", list: false, searchable: false }),
   email: (options) => build("string", options, { format: "email" }),
   url: (options) => build("string", options, { format: "url" }),
   tel: (options) => build("string", options, { format: "tel" }),
@@ -116,7 +123,7 @@ function pluralize(value) {
 }
 
 // src/resource/define.ts
-var RESERVED_FIELD_NAMES = ["id", "createdAt", "updatedAt"];
+var RESERVED_FIELD_NAMES = ["id", "createdAt", "updatedAt", "deletedAt"];
 function clientResource(resource) {
   const { hooks, computed, $types, ...rest } = resource;
   void hooks;
@@ -195,6 +202,7 @@ function defineResource(config) {
     titleField,
     defaultSort,
     perPage,
+    softDelete: config.softDelete === true,
     fields,
     $types: void 0
   };
@@ -379,6 +387,19 @@ function fieldSchema(def) {
       if (def.maxItems !== void 0) s = s.refine((values) => values.length <= def.maxItems, `Choose at most ${def.maxItems}`);
       return s;
     }
+    case "tags": {
+      const maxLength = def.maxLength ?? 32;
+      let s = z.array(
+        z.string({ error: "Each tag is text" }).trim().min(1, "A tag can't be blank").max(maxLength, `A tag can be at most ${maxLength} characters`),
+        { error: typeError("Add one or more tags") }
+      ).refine((values) => new Set(values.map((value) => value.toLowerCase())).size === values.length, "Each tag can be added once");
+      const min = def.minItems ?? (def.required ? 1 : 0);
+      if (min > 0) s = s.refine((values) => values.length >= min, min === 1 ? "Add at least one tag" : `Add at least ${min} tags`);
+      if (def.maxItems !== void 0) s = s.refine((values) => values.length <= def.maxItems, `Add at most ${def.maxItems} tags`);
+      return s;
+    }
+    case "json":
+      return def.object ? z.record(z.string(), z.json(), { error: typeError("Enter a JSON object") }) : z.json();
     case "file":
       return z.string({ error: typeError("Upload a file") }).regex(OBJECT_KEY, "Invalid file");
     case "belongsTo":
@@ -412,6 +433,7 @@ function createValidators(resource) {
 
 // src/resource/policy.ts
 var ROLE = /^(\*|[a-z][a-z0-9_-]{0,31})$/;
+var FIELD = /^[a-z][A-Za-z0-9]*$/;
 var PolicyError = class extends Error {
   constructor(message) {
     super(message);
@@ -429,7 +451,25 @@ function definePolicy(config) {
     }
     return [...new Set(roles)];
   };
-  return { resource: config.resource, read: clean("read"), create: clean("create"), update: clean("update"), delete: clean("delete") };
+  const policy = {
+    resource: config.resource,
+    read: clean("read"),
+    create: clean("create"),
+    update: clean("update"),
+    delete: clean("delete")
+  };
+  if (config.own) {
+    const { field: field2, except = [] } = config.own;
+    if (!FIELD.test(field2)) {
+      throw new PolicyError(`Policy ${config.resource}.own: "${field2}" is not a field name (camelCase, starting with a lowercase letter).`);
+    }
+    for (const role of except) {
+      if (role === "*") throw new PolicyError(`Policy ${config.resource}.own.except: "*" exempts everyone, which is the same as leaving out \`own\`.`);
+      if (!ROLE.test(role)) throw new PolicyError(`Policy ${config.resource}.own.except: invalid role "${role}" (lowercase letters, digits, _ or -).`);
+    }
+    policy.own = { field: field2, except: [...new Set(except)] };
+  }
+  return policy;
 }
 function can(policy, role, action) {
   if (!policy) return true;
@@ -437,6 +477,12 @@ function can(policy, role, action) {
   if (allowed.includes("*")) return Boolean(role);
   return Boolean(role) && allowed.includes(role);
 }
+function ownershipFilter(policy, user) {
+  const own = policy?.own;
+  if (!own || !user) return null;
+  if (user.role != null && own.except.includes(user.role)) return null;
+  return { field: own.field, value: user.id };
+}
 function allowedActions(policy, role) {
   return {
     read: can(policy, role, "read"),
@@ -448,6 +494,7 @@ function allowedActions(policy, role) {
 
 export {
   STRING_FORMATS,
+  TEXT_FORMATS,
   NUMBER_FORMATS,
   FILE_CATEGORIES,
   mimeTypesFor,
@@ -487,5 +534,6 @@ export {
   PolicyError,
   definePolicy,
   can,
+  ownershipFilter,
   allowedActions
 };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { F as Field, C as CreateInput, U as UpdateInput, R as Resource, S as StoredField } from './policy-dc9NbbgZ.js';
-export { B as BelongsToField, a as BooleanField, b as ClientResource, D as DEFAULT_FILE_MAX_BYTES, c as DateField, d as DateTimeField, E as EnumField, e as FILE_CATEGORIES, f as FieldKind, g as FieldValue, h as FileCategory, i as FileField, j as FloatField, H as HasManyField, I as IntField, M as MultiSelectField, N as NUMBER_FORMATS, k as NumberFormat, P as Policy, l as PolicyAction, m as PolicyConfig, n as PolicyError, o as RESERVED_FIELD_NAMES, p as RecordOf, q as ResourceConfig, r as ResourceDefinitionError, s as STRING_FORMATS, t as StringField, u as StringFormat, T as TextField, v as allowedActions, w as can, x as clientResource, y as columnName, z as defaultFieldLabel, A as definePolicy, G as defineResource, J as field, K as fileMaxBytes, L as mimeTypesFor, O as storedFields } from './policy-dc9NbbgZ.js';
+import { F as Field, C as CreateInput, U as UpdateInput, R as Resource, S as StoredField } from './policy-DFimkxdx.js';
+export { B as BelongsToField, a as BooleanField, b as ClientResource, D as DEFAULT_FILE_MAX_BYTES, c as DateField, d as DateTimeField, E as EnumField, e as FILE_CATEGORIES, f as FieldKind, g as FieldValue, h as FileCategory, i as FileField, j as FloatField, H as HasManyField, I as IntField, J as JsonField, k as JsonOptions, M as MultiSelectField, N as NUMBER_FORMATS, l as NumberFormat, P as Policy, m as PolicyAction, n as PolicyConfig, o as PolicyError, p as PolicyOwnership, q as RESERVED_FIELD_NAMES, r as RecordOf, s as ResourceConfig, t as ResourceDefinitionError, u as STRING_FORMATS, v as StringField, w as StringFormat, T as TEXT_FORMATS, x as TagsField, y as TagsOptions, z as TextField, A as TextFormat, G as allowedActions, K as can, L as clientResource, O as columnName, Q as defaultFieldLabel, V as definePolicy, W as defineResource, X as field, Y as fileMaxBytes, Z as mimeTypesFor, _ as ownershipFilter, $ as storedFields } from './policy-DFimkxdx.js';
 import { z } from 'zod';
 
 /**
@@ -375,7 +375,7 @@ declare function formatValue(def: StoredField | {
 
 /**
  * Form state for a resource: strings for text-like inputs, booleans for toggles, and a
- * JSON array string for multiselects.
+ * JSON array string for multiselects and tags.
  * These helpers convert between records, form state, and API input so every admin
  * form handles empty values, numbers, and defaults the same way.
  */
@@ -388,7 +388,7 @@ declare function initialFormValues(resource: Pick<Resource, "fields">, record?:
  * empty required fields are left for validation to report as "Required".
  */
 declare function formValuesToInput(resource: Pick<Resource, "fields">, values: FormValues, mode: "create" | "edit"): Record<string, unknown>;
-/** A multiselect's form state (a JSON array string) as the picked values. */
+/** A multiselect's or tags field's form state (a JSON array string) as the picked values. */
 declare function parseMultiValue(raw: string | boolean | undefined): string[];
 /** Field errors keyed by field name, from validation or API issues (first message wins). */
 declare function issuesByField(issues: {
@@ -529,6 +529,6 @@ interface SeedContext {
 type Seed = (context: SeedContext) => void | Promise<void>;
 declare function defineSeed(seed: Seed): Seed;
 
-declare const FLARE_VERSION = "0.8.0";
+declare const FLARE_VERSION = "0.9.0";
 
 export { type BelongsToRelation, type Country, CreateInput, FLARE_VERSION, type Fake, Field, type FormValues, type FormatOptions, type HasManyRelation, type InsertMany, type MailMessage, type MailResult, type Mailer, type MailerOptions, PBKDF2_ITERATIONS, type ReadUrlOptions, RelationError, type RelationGraph, Resource, type ResourceRelations, type ResourceValidators, SNIFF_BYTES, SUBSCRIPTION_STATUSES, type Seed, type SeedContext, type Storage, type StorageBucket, type StorageOptions, StoredField, type SubscriptionLike, type SubscriptionState, type SubscriptionStatus, type Tone, type TransactionalEmail, UpdateInput, type UploadUrlOptions, camelCase, checkoutPaid, countries, countryName, createFake, createMailer, createObjectKey, createStorage, createValidators, currentPeriodEnd, defineSeed, fake, fieldSchema, fileKeyPrefix, flagEmoji, formValuesToInput, formatPhone, formatValue, grantsAccess, hashPassword, humanize, importSigningKey, initialFormValues, isColor, isCountryCode, isDomain, isLiveSubscription, isPhoneNumber, isSlug, issuesByField, kebabCase, matchesContentType, normalizeDomain, optionLabel, parseMultiValue, pascalCase, pluralize, randomLetters, relationGraph, renderTransactionalEmail, shouldApplySubscription, signToken, slugify, snakeCase, sniffMatches, splitPhone, statusTone, subscriptionPriceId, subscriptionState, toE164, toSubscriptionStatus, verifyPassword, verifyToken, words };

package/dist/index.js

@@ -6,6 +6,7 @@ import {
   RESERVED_FIELD_NAMES,
   ResourceDefinitionError,
   STRING_FORMATS,
+  TEXT_FORMATS,
   allowedActions,
   camelCase,
   can,
@@ -32,6 +33,7 @@ import {
   kebabCase,
   mimeTypesFor,
   normalizeDomain,
+  ownershipFilter,
   pascalCase,
   pluralize,
   slugify,
@@ -40,7 +42,7 @@ import {
   storedFields,
   toE164,
   words
-} from "./chunk-JYWV3AF6.js";
+} from "./chunk-AAXNSIZG.js";
 
 // src/password.ts
 var ALGORITHM = "pbkdf2-sha256";
@@ -605,6 +607,13 @@ function formatValue(def, value, options = {}) {
       return optionLabel(def, String(value));
     case "multiselect":
       return Array.isArray(value) && value.length ? value.map((item) => optionLabel(def, String(item))).join(", ") : "\u2014";
+    case "tags":
+      return Array.isArray(value) && value.length ? value.map(String).join(", ") : "\u2014";
+    case "json": {
+      if (value === null || value === void 0) return "\u2014";
+      const text2 = typeof value === "string" ? value : JSON.stringify(value);
+      return text2.length > 60 ? `${text2.slice(0, 59)}\u2026` : text2;
+    }
     case "string":
       if (def.format === "tel") return formatPhone(String(value));
       if (def.format === "country") return `${flagEmoji(String(value))} ${countryName(String(value), locale.split("-")[0])}`.trim();
@@ -622,7 +631,8 @@ function initialFormValues(resource, record) {
   for (const [key, def] of storedFields(resource)) {
     const source = record ? record[key] : "default" in def ? def.default : void 0;
     if (def.kind === "boolean") values[key] = source === true || source === 1;
-    else if (def.kind === "multiselect") values[key] = JSON.stringify(Array.isArray(source) ? source : []);
+    else if (def.kind === "multiselect" || def.kind === "tags") values[key] = JSON.stringify(Array.isArray(source) ? source : []);
+    else if (def.kind === "json") values[key] = source === null || source === void 0 ? "" : JSON.stringify(source, null, 2);
     else if (source === null || source === void 0) values[key] = "";
     else if (source instanceof Date) values[key] = source.toISOString();
     else values[key] = String(source);
@@ -637,12 +647,26 @@ function formValuesToInput(resource, values, mode) {
       input[key] = raw === true;
       continue;
     }
-    if (def.kind === "multiselect") {
+    if (def.kind === "multiselect" || def.kind === "tags") {
       const picked = parseMultiValue(raw);
       if (picked.length === 0 && mode === "create" && "default" in def && def.default !== void 0) continue;
       input[key] = picked.length === 0 && !def.required ? null : picked;
       continue;
     }
+    if (def.kind === "json") {
+      const source = typeof raw === "string" ? raw.trim() : "";
+      if (source === "") {
+        if (mode === "create" && "default" in def && def.default !== void 0) continue;
+        if (!def.required) input[key] = null;
+        continue;
+      }
+      try {
+        input[key] = JSON.parse(source);
+      } catch {
+        input[key] = Number.NaN;
+      }
+      continue;
+    }
     const text2 = typeof raw === "string" ? raw : "";
     const empty = text2.trim() === "";
     if (empty) {
@@ -995,7 +1019,7 @@ function createFake(seed = 20260101) {
 var fake = createFake();
 
 // src/index.ts
-var FLARE_VERSION = "0.8.0";
+var FLARE_VERSION = "0.9.0";
 export {
   DEFAULT_FILE_MAX_BYTES,
   FILE_CATEGORIES,
@@ -1009,6 +1033,7 @@ export {
   SNIFF_BYTES,
   STRING_FORMATS,
   SUBSCRIPTION_STATUSES,
+  TEXT_FORMATS,
   allowedActions,
   camelCase,
   can,
@@ -1053,6 +1078,7 @@ export {
   mimeTypesFor,
   normalizeDomain,
   optionLabel,
+  ownershipFilter,
   parseMultiValue,
   pascalCase,
   pluralize,

package/dist/{policy-dc9NbbgZ.d.ts → policy-DFimkxdx.d.ts}

@@ -6,7 +6,7 @@
  * rule in a descriptor takes effect without re-running the generator. Only
  * storage-level changes (kind, nullability, uniqueness, relations) need a migration.
  */
-type FieldKind = "string" | "text" | "int" | "float" | "boolean" | "date" | "datetime" | "enum" | "multiselect" | "file" | "belongsTo" | "hasMany";
+type FieldKind = "string" | "text" | "int" | "float" | "boolean" | "date" | "datetime" | "enum" | "multiselect" | "tags" | "json" | "file" | "belongsTo" | "hasMany";
 /** Options shared by every stored (non-hasMany) field. */
 interface CommonOptions<T> {
     label?: string;
@@ -50,9 +50,49 @@ interface StringOptions extends CommonOptions<string> {
     format?: StringFormat;
     pattern?: string;
 }
+/**
+ * What long text holds.
+ *
+ * The column is `text` either way. `markdown` changes the editor — a split write/preview
+ * pane rather than a plain textarea — and how the value is rendered. Nothing is escaped
+ * or sanitised on the way in: it is stored exactly as typed, and rendered as Markdown
+ * where the dashboard shows it.
+ */
+type TextFormat = "markdown";
+declare const TEXT_FORMATS: readonly TextFormat[];
 interface TextOptions extends CommonOptions<string> {
     maxLength?: number;
     minLength?: number;
+    format?: TextFormat;
+}
+/**
+ * Free-text labels, as many as you like.
+ *
+ * `multiselect` is the one to reach for when the vocabulary is fixed and known — it
+ * validates against its options and renders a picker. `tags` is for the other case: the
+ * person typing decides what the values are. Stored as a JSON array, like a multiselect,
+ * so a row holds `["urgent", "q3"]` rather than a comma-joined string nobody can query.
+ */
+interface TagsOptions extends Omit<CommonOptions<string[]>, "unique"> {
+    /** Fewest / most tags. A required field needs at least one. */
+    minItems?: number;
+    maxItems?: number;
+    /** Longest a single tag may be. Default 32. */
+    maxLength?: number;
+    /** Shown in the input before anything is typed, e.g. "add a label". */
+    placeholder?: string;
+}
+/**
+ * Anything that is not table-shaped: a settings blob, a webhook payload, metadata.
+ *
+ * Stored as JSON — a `text` column on SQLite, `jsonb` on Postgres. Validated as parseable
+ * and nothing more, because the point of the field is that its shape is not declared. If
+ * you find yourself reaching for it to hold something with a known shape, that shape wants
+ * fields of its own, or a resource of its own.
+ */
+interface JsonOptions extends Omit<CommonOptions<unknown>, "unique"> {
+    /** Reject anything that is not a JSON object, for a settings blob. Default false. */
+    object?: boolean;
 }
 /**
  * What a number means, which decides how it is shown and entered.
@@ -121,6 +161,8 @@ type EnumField<O extends string = string, R extends boolean = boolean> = Base<"e
 type MultiSelectField<O extends string = string, R extends boolean = boolean> = Base<"multiselect", R> & MultiSelectOptions<O> & {
     options: readonly O[];
 };
+type TagsField<R extends boolean = boolean> = Base<"tags", R> & TagsOptions;
+type JsonField<R extends boolean = boolean> = Base<"json", R> & JsonOptions;
 type FileField<R extends boolean = boolean> = Base<"file", R> & FileOptions & {
     /** Accepted categories from the `file:[image,pdf]` grammar. */
     accept: readonly FileCategory[];
@@ -134,7 +176,7 @@ type HasManyField = {
     required: false;
     target: string;
 } & HasManyOptions;
-type Field = StringField | TextField | IntField | FloatField | BooleanField | DateField | DateTimeField | EnumField | MultiSelectField | FileField | BelongsToField | HasManyField;
+type Field = StringField | TextField | IntField | FloatField | BooleanField | DateField | DateTimeField | EnumField | MultiSelectField | TagsField | JsonField | FileField | BelongsToField | HasManyField;
 type StoredField = Exclude<Field, HasManyField>;
 /** File categories usable in `file:[...]` and the MIME types each allows. */
 declare const FILE_CATEGORIES: {
@@ -172,6 +214,12 @@ declare const field: {
     radio: <const V extends readonly [string, ...string[]], const O extends EnumOptions<V[number]>>(values: V, options?: O) => EnumField<V[number], Req<O>> & O;
     /** Any number of a list, picked with checkboxes. Stored as a JSON array. */
     multiselect: <const V extends readonly [string, ...string[]], const O extends MultiSelectOptions<V[number]>>(values: V, options?: O) => MultiSelectField<V[number], Req<O>> & O;
+    /** Free-text labels, as many as wanted. Stored as a JSON array. */
+    tags: <const O extends TagsOptions>(options?: O) => TagsField<Req<O>> & O;
+    /** Anything not table-shaped: a settings blob, a payload, metadata. Stored as JSON. */
+    json: <const O extends JsonOptions>(options?: O) => JsonField<Req<O>> & O;
+    /** Long text written as Markdown: a split editor, rendered where it is shown. */
+    markdown: <const O extends Omit<TextOptions, "format">>(options?: O) => TextField<Req<O>> & O;
     email: <const O extends Omit<StringOptions, "format">>(options?: O) => StringField<Req<O>> & O;
     url: <const O extends Omit<StringOptions, "format">>(options?: O) => StringField<Req<O>> & O;
     tel: <const O extends Omit<StringOptions, "format">>(options?: O) => StringField<Req<O>> & O;
@@ -232,7 +280,7 @@ type RecordOf<Fields> = Simplify<{
     } ? FieldValue<Fields[K]> : FieldValue<Fields[K]> | null;
 }>;
 
-declare const RESERVED_FIELD_NAMES: readonly ["id", "createdAt", "updatedAt"];
+declare const RESERVED_FIELD_NAMES: readonly ["id", "createdAt", "updatedAt", "deletedAt"];
 type FieldKey<Fields> = Extract<keyof Fields, string>;
 interface ResourceConfig<Fields extends Record<string, Field>> {
     /** PascalCase singular name, e.g. "Contact", "OrderItem". */
@@ -259,6 +307,20 @@ interface ResourceConfig<Fields extends Record<string, Field>> {
     };
     /** Page size for list endpoints and tables. Default 25. */
     perPage?: number;
+    /**
+     * Keep deleted records instead of removing them.
+     *
+     * Adds a nullable `deletedAt` column. A delete stamps it; every read leaves those rows
+     * out, so nothing else in the app has to know. The dashboard grows a Trash view with
+     * Restore and Delete forever, and `?deleted=only` lists them over the API.
+     *
+     * Two things it does not change, both worth knowing before switching it on. A unique
+     * value is still taken by a deleted row — an email freed by deleting a user cannot be
+     * signed up again until the row is really gone. And a foreign key still points at it, so
+     * a deleted parent keeps its children valid, which is usually what you wanted but is a
+     * decision rather than an accident.
+     */
+    softDelete?: boolean;
     /**
      * Your logic, beside the fields it belongs to. Every write — the REST API, the
      * dashboard's forms, a seed, an import — goes through the same store, so a hook here
@@ -323,6 +385,8 @@ interface Resource<Fields extends Record<string, Field> = Record<string, Field>>
         direction: "asc" | "desc";
     };
     perPage: number;
+    /** Deleted records are kept and hidden, not removed. See ResourceConfig.softDelete. */
+    softDelete: boolean;
     /** Fields with labels filled in. */
     fields: Fields & Record<string, Field & {
         label: string;
@@ -364,13 +428,33 @@ declare function storedFields(resource: Pick<Resource, "fields">): [string, Stor
 declare const columnName: (key: string) => string;
 
 /**
- * Resource-level policies: which roles may read, create, update, or delete a resource.
+ * Resource-level policies: which roles may read, create, update, or delete a resource,
+ * and — with `own` — which rows each user may touch.
  *
  * Policies are plain data, like descriptors, so the API layer and the admin UI read the
- * same rules at runtime. Field-level rules and per-record ownership are deliberately out
- * of scope for v1.
+ * same rules at runtime. That is why ownership is a field name and a list of exempt
+ * roles rather than a callback: it can be read, printed and reasoned about without being
+ * run, and it crosses to the dashboard unchanged. Field-level rules are still out of
+ * scope.
+ *
+ * Roles and ownership answer different questions and compose. The role decides whether
+ * you may list invoices at all; ownership decides which invoices "all of them" means.
  */
 type PolicyAction = "list" | "read" | "create" | "update" | "delete";
+/**
+ * Per-record ownership: each user sees and changes only the rows that are theirs.
+ *
+ * `field` is a field on the resource holding the owning user's id — normally a
+ * `belongsTo("User")`. The store fills it in on create, requires it to match on read,
+ * update and delete, and adds it to every list query, so a row that isn't yours is a
+ * 404 rather than a 403: a user who can't see a record shouldn't learn it exists.
+ */
+interface PolicyOwnership {
+    /** The field holding the owning user's id, e.g. "userId". */
+    field: string;
+    /** Roles that see and change every row regardless — usually `["admin"]`. */
+    except: string[];
+}
 /** Roles allowed per action; `"*"` means any signed-in user. */
 interface Policy {
     resource: string;
@@ -378,6 +462,8 @@ interface Policy {
     create: string[];
     update: string[];
     delete: string[];
+    /** Restrict every action to the user's own rows. Absent means no restriction. */
+    own?: PolicyOwnership;
 }
 interface PolicyConfig {
     resource: string;
@@ -385,6 +471,16 @@ interface PolicyConfig {
     create?: string[];
     update?: string[];
     delete?: string[];
+    /**
+     * Restrict every action to the user's own rows.
+     *
+     * `{ field: "userId" }` is the common case: `except` defaults to none, so even an
+     * admin sees only their own unless you say otherwise.
+     */
+    own?: {
+        field: string;
+        except?: string[];
+    };
 }
 declare class PolicyError extends Error {
     constructor(message: string);
@@ -396,7 +492,20 @@ declare function definePolicy(config: PolicyConfig): Policy;
  * `flare gen policy <Resource> --roles …` to restrict a resource.
  */
 declare function can(policy: Policy | undefined | null, role: string | null | undefined, action: PolicyAction): boolean;
+/**
+ * The rows this user is limited to, or null when they may touch every row.
+ *
+ * Null for three different reasons — no policy, no `own`, or a role in `except` — and
+ * the caller treats them the same, because they mean the same thing.
+ */
+declare function ownershipFilter(policy: Policy | undefined | null, user: {
+    id: string;
+    role?: string | null;
+} | null | undefined): {
+    field: string;
+    value: string;
+} | null;
 /** Actions `role` may perform, for hiding UI it can't use. */
 declare function allowedActions(policy: Policy | undefined | null, role: string | null | undefined): Record<Exclude<PolicyAction, "list">, boolean>;
 
-export { definePolicy as A, type BelongsToField as B, type CreateInput as C, DEFAULT_FILE_MAX_BYTES as D, type EnumField as E, type Field as F, defineResource as G, type HasManyField as H, type IntField as I, field as J, fileMaxBytes as K, mimeTypesFor as L, type MultiSelectField as M, NUMBER_FORMATS as N, storedFields as O, type Policy as P, type Resource as R, type StoredField as S, type TextField as T, type UpdateInput as U, type BooleanField as a, type ClientResource as b, type DateField as c, type DateTimeField as d, FILE_CATEGORIES as e, type FieldKind as f, type FieldValue as g, type FileCategory as h, type FileField as i, type FloatField as j, type NumberFormat as k, type PolicyAction as l, type PolicyConfig as m, PolicyError as n, RESERVED_FIELD_NAMES as o, type RecordOf as p, type ResourceConfig as q, ResourceDefinitionError as r, STRING_FORMATS as s, type StringField as t, type StringFormat as u, allowedActions as v, can as w, clientResource as x, columnName as y, defaultFieldLabel as z };
+export { storedFields as $, type TextFormat as A, type BelongsToField as B, type CreateInput as C, DEFAULT_FILE_MAX_BYTES as D, type EnumField as E, type Field as F, allowedActions as G, type HasManyField as H, type IntField as I, type JsonField as J, can as K, clientResource as L, type MultiSelectField as M, NUMBER_FORMATS as N, columnName as O, type Policy as P, defaultFieldLabel as Q, type Resource as R, type StoredField as S, TEXT_FORMATS as T, type UpdateInput as U, definePolicy as V, defineResource as W, field as X, fileMaxBytes as Y, mimeTypesFor as Z, ownershipFilter as _, type BooleanField as a, type ClientResource as b, type DateField as c, type DateTimeField as d, FILE_CATEGORIES as e, type FieldKind as f, type FieldValue as g, type FileCategory as h, type FileField as i, type FloatField as j, type JsonOptions as k, type NumberFormat as l, type PolicyAction as m, type PolicyConfig as n, PolicyError as o, type PolicyOwnership as p, RESERVED_FIELD_NAMES as q, type RecordOf as r, type ResourceConfig as s, ResourceDefinitionError as t, STRING_FORMATS as u, type StringField as v, type StringFormat as w, type TagsField as x, type TagsOptions as y, type TextField as z };

package/dist/server.d.ts

@@ -1,6 +1,6 @@
 import * as drizzle_orm_sqlite_core from 'drizzle-orm/sqlite-core';
 import { BaseSQLiteDatabase, SQLiteTable, SQLiteColumn } from 'drizzle-orm/sqlite-core';
-import { S as StoredField, R as Resource, F as Field, P as Policy } from './policy-dc9NbbgZ.js';
+import { S as StoredField, R as Resource, F as Field, P as Policy } from './policy-DFimkxdx.js';
 
 /**
  * The handful of things a resource store needs a database to do.
@@ -122,7 +122,18 @@ declare function isSearchable(def: StoredField): boolean;
  * resource. Only fields the descriptor marks sortable/filterable/searchable are
  * accepted, so clients can't probe arbitrary columns.
  */
-declare function parseListQuery(resource: Resource, params: URLSearchParams): {
+declare function parseListQuery(resource: Resource, params: URLSearchParams, 
+/**
+ * The largest page this caller may ask for.
+ *
+ * The cap exists to stop a request from the outside asking for ten thousand rows at
+ * once. Server-side callers that page through everything deliberately — the CSV
+ * export — pass their own, which is why this is an argument rather than a constant
+ * everything obeys.
+ */
+options?: {
+    maxPerPage?: number;
+}): {
     query: ListQuery;
 } | {
     issues: QueryIssue[];
@@ -215,7 +226,9 @@ declare function createResourceStore(options: ResourceStoreOptions): {
     resource: Resource<Record<string, Field>>;
     table: SQLiteTable<drizzle_orm_sqlite_core.TableConfig> | undefined;
     /** `params`: page, perPage, sort, q, filter[field], cursor (as parsed by parseListQuery). */
-    list(params: URLSearchParams): Promise<Result<ListResult>>;
+    list(params: URLSearchParams, options?: {
+        maxPerPage?: number;
+    }): Promise<Result<ListResult>>;
     get(id: string): Promise<Result<Record<string, unknown>>>;
     /** Title-field values for a set of ids (for showing relations). Missing ids are omitted. */
     titles(ids: string[]): Promise<Record<string, string>>;
@@ -271,7 +284,9 @@ declare function createResourceHandlers(options: ResourceHandlerOptions): {
     store: {
         resource: Resource<Record<string, Field>>;
         table: SQLiteTable<drizzle_orm_sqlite_core.TableConfig> | undefined;
-        list(params: URLSearchParams): Promise<Result<ListResult>>;
+        list(params: URLSearchParams, options?: {
+            maxPerPage?: number;
+        }): Promise<Result<ListResult>>;
         get(id: string): Promise<Result<Record<string, unknown>>>;
         titles(ids: string[]): Promise<Record<string, string>>;
         create(raw: unknown): Promise<Result<Record<string, unknown>>>;

package/dist/server.js

@@ -3,7 +3,7 @@ import {
   columnName,
   createValidators,
   storedFields
-} from "./chunk-JYWV3AF6.js";
+} from "./chunk-AAXNSIZG.js";
 
 // ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudfl_21866ab18c10d2d988b916e06105fbce/node_modules/drizzle-orm/entity.js
 var entityKind = /* @__PURE__ */ Symbol.for("drizzle:entityKind");
@@ -1319,7 +1319,7 @@ function coerce(def, raw) {
       return raw;
   }
 }
-function parseListQuery(resource, params) {
+function parseListQuery(resource, params, options = {}) {
   const issues = [];
   const fields = new Map(storedFields(resource));
   const positiveInt = (name, fallback, max = Number.MAX_SAFE_INTEGER) => {
@@ -1333,7 +1333,7 @@ function parseListQuery(resource, params) {
     return value;
   };
   const page = positiveInt("page", 1);
-  const perPage = positiveInt("perPage", resource.perPage, MAX_PER_PAGE);
+  const perPage = positiveInt("perPage", resource.perPage, options.maxPerPage ?? MAX_PER_PAGE);
   let sort = resource.defaultSort;
   const rawSort = params.get("sort");
   if (rawSort) {
@@ -1449,8 +1449,8 @@ function createResourceStore(options) {
     resource,
     table,
     /** `params`: page, perPage, sort, q, filter[field], cursor (as parsed by parseListQuery). */
-    async list(params) {
-      const parsed = parseListQuery(resource, params);
+    async list(params, options2 = {}) {
+      const parsed = parseListQuery(resource, params, options2);
       if ("issues" in parsed) return fail(400, "Invalid query.", { queryIssues: parsed.issues });
       const { page, perPage, sort, q, filters, cursor } = parsed.query;
       const isDateField = (key) => {
@@ -1799,6 +1799,20 @@ function fieldJsonSchema(def) {
       if (def.maxItems !== void 0) schema.maxItems = def.maxItems;
       return schema;
     }
+    case "tags": {
+      const schema = {
+        ...base,
+        type: "array",
+        items: { type: "string", maxLength: def.maxLength ?? 32 },
+        uniqueItems: true,
+        examples: [["urgent", "q3"]]
+      };
+      if (def.minItems !== void 0) schema.minItems = def.minItems;
+      if (def.maxItems !== void 0) schema.maxItems = def.maxItems;
+      return schema;
+    }
+    case "json":
+      return def.object ? { ...base, type: "object", description: base.description ?? "A JSON object." } : { ...base, description: base.description ?? "Any JSON value." };
     case "file":
       return { ...base, type: "string", description: base.description ?? "Storage key of an uploaded file." };
     case "belongsTo":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flaredev/core",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Flare runtime: resource descriptors, field grammar, and Cloudflare-native helpers",
   "license": "MIT",
   "author": "Muke Johnbaptist",