@flaredev/core 0.1.2 → 0.3.0

package/dist/server.d.ts

@@ -1,6 +1,6 @@
 import * as drizzle_orm_sqlite_core from 'drizzle-orm/sqlite-core';
 import { BaseSQLiteDatabase, SQLiteTable } from 'drizzle-orm/sqlite-core';
-import { S as StoredField, R as Resource, F as Field } from './define-D5CtCkOm.js';
+import { S as StoredField, R as Resource, F as Field, P as Policy } from './policy-BqRg9RVM.js';
 
 interface ListQuery {
     page: number;
@@ -153,4 +153,31 @@ declare function createResourceHandlers(options: ResourceHandlerOptions): {
     };
 };
 
-export { type AnyDatabase, type Authorize, type AuthorizeContext, type ChangeEvent, type Failure, type FieldIssue, type ListQuery, type ListResult, type QueryIssue, type ResourceAction, type ResourceHandlerOptions, type ResourceStore, type ResourceStoreOptions, type Result, createResourceHandlers, createResourceStore, isFilterable, isSearchable, isSortable, parseListQuery };
+/**
+ * An OpenAPI 3.1 document for an app's generated REST API, built at request time
+ * from the same descriptors and policies the API itself runs on, so it can't drift.
+ *
+ * Operations are filtered by role: a signed-in user sees what their role may call
+ * (admins everything), a visitor only the sign-in endpoints. `visibility: "public"`
+ * lists every operation to everyone.
+ */
+
+type Schema = Record<string, unknown>;
+interface OpenApiOptions {
+    resources: readonly Resource[];
+    policies?: Record<string, Policy | undefined>;
+    /** The viewer's role; null for a signed-out visitor. */
+    role: string | null;
+    /** "role" (default): only operations the viewer's role may call. "public": all of them. */
+    visibility?: "role" | "public";
+    title?: string;
+    version?: string;
+    description?: string;
+    /** Absolute origin the "Try it" requests go to, e.g. https://app.example.com. */
+    serverUrl?: string;
+}
+/** JSON Schema for one field value (never null; nullability is added by the caller). */
+declare function fieldJsonSchema(def: StoredField): Schema;
+declare function openApiDocument(options: OpenApiOptions): Schema;
+
+export { type AnyDatabase, type Authorize, type AuthorizeContext, type ChangeEvent, type Failure, type FieldIssue, type ListQuery, type ListResult, type OpenApiOptions, type QueryIssue, type ResourceAction, type ResourceHandlerOptions, type ResourceStore, type ResourceStoreOptions, type Result, createResourceHandlers, createResourceStore, fieldJsonSchema, isFilterable, isSearchable, isSortable, openApiDocument, parseListQuery };

package/dist/server.js

@@ -1,7 +1,8 @@
 import {
+  can,
   createValidators,
   storedFields
-} from "./chunk-DARDHZPX.js";
+} from "./chunk-434JXSDV.js";
 
 // ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudfl_b372b29e6d5511672c7f9f9d2ac40572/node_modules/drizzle-orm/entity.js
 var entityKind = /* @__PURE__ */ Symbol.for("drizzle:entityKind");
@@ -381,8 +382,8 @@ var PgColumnBuilder = class extends ColumnBuilder {
   array(size) {
     return new PgArrayBuilder(this.config.name, this, size);
   }
-  references(ref, actions = {}) {
-    this.foreignKeyConfigs.push({ ref, actions });
+  references(ref2, actions = {}) {
+    this.foreignKeyConfigs.push({ ref: ref2, actions });
     return this;
   }
   unique(name, config) {
@@ -401,11 +402,11 @@ var PgColumnBuilder = class extends ColumnBuilder {
   }
   /** @internal */
   buildForeignKeys(column, table) {
-    return this.foreignKeyConfigs.map(({ ref, actions }) => {
+    return this.foreignKeyConfigs.map(({ ref: ref2, actions }) => {
       return iife(
-        (ref2, actions2) => {
+        (ref22, actions2) => {
           const builder = new ForeignKeyBuilder(() => {
-            const foreignColumn = ref2();
+            const foreignColumn = ref22();
             return { columns: [column], foreignColumns: [foreignColumn] };
           });
           if (actions2.onUpdate) {
@@ -416,7 +417,7 @@ var PgColumnBuilder = class extends ColumnBuilder {
           }
           return builder.build(table);
         },
-        ref,
+        ref2,
         actions
       );
     });
@@ -1488,11 +1489,276 @@ function createResourceHandlers(options) {
     store
   };
 }
+
+// src/server/openapi.ts
+var E164 = "^\\+[1-9]\\d{6,14}$";
+function fieldJsonSchema(def) {
+  const base = {};
+  if (def.helpText) base.description = def.helpText;
+  switch (def.kind) {
+    case "string": {
+      const schema = { ...base, type: "string", maxLength: def.maxLength ?? 255 };
+      if (def.minLength !== void 0) schema.minLength = def.minLength;
+      if (def.pattern) schema.pattern = def.pattern;
+      switch (def.format) {
+        case "email":
+          return { ...schema, format: "email", examples: ["ada@example.com"] };
+        case "url":
+          return { ...schema, format: "uri", examples: ["https://example.com"] };
+        case "tel":
+          return { ...schema, pattern: E164, description: "International number in E.164 form.", examples: ["+256772123456"] };
+        case "domain":
+          return { ...schema, format: "hostname", description: "A hostname, stored lowercase without scheme or path.", examples: ["example.com"] };
+        case "country":
+          return { ...schema, pattern: "^[A-Z]{2}$", description: "ISO 3166-1 alpha-2 country code.", examples: ["UG"] };
+        case "color":
+          return { ...schema, pattern: "^#[0-9a-f]{6}$", description: "Hex colour.", examples: ["#f2541d"] };
+        case "slug":
+          return { ...schema, pattern: "^[a-z0-9]+(?:-[a-z0-9]+)*$", examples: ["my-first-post"] };
+        default:
+          return schema;
+      }
+    }
+    case "text":
+      return { ...base, type: "string", maxLength: def.maxLength ?? 65535 };
+    case "int":
+    case "float": {
+      const schema = { ...base, type: def.kind === "int" ? "integer" : "number" };
+      if (def.min !== void 0) schema.minimum = def.min;
+      if (def.max !== void 0) schema.maximum = def.max;
+      return schema;
+    }
+    case "boolean":
+      return { ...base, type: "boolean" };
+    case "date":
+      return { ...base, type: "string", format: "date" };
+    case "datetime":
+      return { ...base, type: "string", format: "date-time" };
+    case "enum":
+      return { ...base, type: "string", enum: [...def.options] };
+    case "multiselect": {
+      const schema = { ...base, type: "array", items: { type: "string", enum: [...def.options] }, uniqueItems: true };
+      if (def.minItems !== void 0) schema.minItems = def.minItems;
+      if (def.maxItems !== void 0) schema.maxItems = def.maxItems;
+      return schema;
+    }
+    case "file":
+      return { ...base, type: "string", description: base.description ?? "Storage key of an uploaded file." };
+    case "belongsTo":
+      return { ...base, type: "string", description: base.description ?? `id of a ${def.target}.` };
+  }
+}
+var nullable = (schema) => ({ ...schema, type: [schema.type, "null"] });
+function resourceSchemas(resource) {
+  const record = { id: { type: "string", format: "uuid", readOnly: true } };
+  const create = {};
+  const required = [];
+  const recordRequired = ["id", "createdAt", "updatedAt"];
+  for (const [key, def] of storedFields(resource)) {
+    const value = { ...fieldJsonSchema(def), title: def.label ?? key };
+    record[key] = def.required ? value : nullable(value);
+    create[key] = def.required ? value : nullable(value);
+    if ("default" in def && def.default !== void 0) create[key] = { ...create[key], default: def.default };
+    if (def.required) recordRequired.push(key);
+    if (def.required && !("default" in def && def.default !== void 0)) required.push(key);
+  }
+  record.createdAt = { type: "string", format: "date-time", readOnly: true };
+  record.updatedAt = { type: "string", format: "date-time", readOnly: true };
+  return {
+    [resource.name]: { type: "object", properties: record, required: recordRequired },
+    [`${resource.name}Create`]: { type: "object", properties: create, required, additionalProperties: false },
+    [`${resource.name}Update`]: { type: "object", properties: create, additionalProperties: false, description: "Only the fields to change." },
+    [`${resource.name}Page`]: {
+      type: "object",
+      properties: {
+        data: { type: "array", items: { $ref: `#/components/schemas/${resource.name}` } },
+        meta: { $ref: "#/components/schemas/PageMeta" }
+      },
+      required: ["data", "meta"]
+    }
+  };
+}
+var json = (schema) => ({ "application/json": { schema } });
+var ref = (name) => ({ $ref: `#/components/schemas/${name}` });
+var problem2 = (description) => ({ description, content: json(ref("Problem")) });
+function rolesNote(policy, action) {
+  if (!policy) return "Any signed-in user.";
+  const roles = policy[action === "list" ? "read" : action];
+  if (roles.includes("*")) return "Any signed-in user.";
+  return roles.length ? `Roles: ${roles.join(", ")}.` : "No role may do this.";
+}
+function listParameters(resource) {
+  const fields = storedFields(resource);
+  const sortable = ["createdAt", "updatedAt", ...fields.filter(([, def]) => isSortable(def)).map(([key]) => key)];
+  const parameters = [
+    { name: "page", in: "query", schema: { type: "integer", minimum: 1, default: 1 } },
+    { name: "perPage", in: "query", schema: { type: "integer", minimum: 1, maximum: 100, default: resource.perPage } },
+    {
+      name: "sort",
+      in: "query",
+      description: "Field to sort by; prefix with - for descending.",
+      schema: { type: "string", enum: sortable.flatMap((key) => [key, `-${key}`]) }
+    }
+  ];
+  if (fields.some(([, def]) => isSearchable(def))) {
+    parameters.push({ name: "q", in: "query", description: "Free-text search across the searchable fields.", schema: { type: "string", maxLength: 200 } });
+  }
+  for (const [key, def] of fields) {
+    if (!isFilterable(def)) continue;
+    parameters.push({ name: `filter[${key}]`, in: "query", description: `Only records whose ${key} equals this.`, schema: fieldJsonSchema(def) });
+  }
+  return parameters;
+}
+function openApiDocument(options) {
+  const { resources, policies = {}, role, visibility = "role" } = options;
+  const allowed = (resource, action) => visibility === "public" || role !== null && can(policies[resource.name], role, action);
+  const paths = {};
+  const schemas = {
+    Problem: {
+      type: "object",
+      properties: {
+        error: { type: "string", examples: ["Validation failed."] },
+        issues: { type: "array", items: { type: "object", properties: { path: { type: "string" }, message: { type: "string" } } } },
+        field: { type: "string", description: "The field a uniqueness conflict is about." }
+      },
+      required: ["error"]
+    },
+    PageMeta: {
+      type: "object",
+      properties: { page: { type: "integer" }, perPage: { type: "integer" }, total: { type: "integer" }, totalPages: { type: "integer" } },
+      required: ["page", "perPage", "total", "totalPages"]
+    }
+  };
+  const tags = [{ name: "Authentication", description: "Sign in here first: the session cookie authorizes every other request." }];
+  const auth = {
+    "/api/auth/sign-up/email": {
+      post: {
+        operationId: "signUp",
+        tags: ["Authentication"],
+        summary: "Create an account",
+        security: [],
+        requestBody: { required: true, content: json({ type: "object", properties: { name: { type: "string" }, email: { type: "string", format: "email" }, password: { type: "string", minLength: 8 } }, required: ["name", "email", "password"] }) },
+        responses: { "200": { description: "Signed up and signed in; sets the session cookie." }, "422": problem2("The email is taken or the password too short.") }
+      }
+    },
+    "/api/auth/sign-in/email": {
+      post: {
+        operationId: "signIn",
+        tags: ["Authentication"],
+        summary: "Sign in",
+        security: [],
+        requestBody: { required: true, content: json({ type: "object", properties: { email: { type: "string", format: "email" }, password: { type: "string" } }, required: ["email", "password"] }) },
+        responses: { "200": { description: "Signed in; sets the session cookie." }, "401": problem2("Wrong email or password.") }
+      }
+    },
+    "/api/auth/get-session": {
+      get: { operationId: "getSession", tags: ["Authentication"], summary: "The current session", responses: { "200": { description: "The signed-in user and session, or null." } } }
+    },
+    "/api/auth/sign-out": {
+      post: { operationId: "signOut", tags: ["Authentication"], summary: "Sign out", responses: { "200": { description: "Signed out; clears the session cookie." } } }
+    }
+  };
+  Object.assign(paths, auth);
+  for (const resource of resources) {
+    const policy = policies[resource.name];
+    const can2 = (action) => allowed(resource, action);
+    if (!["list", "read", "create", "update", "delete"].some(can2)) continue;
+    Object.assign(schemas, resourceSchemas(resource));
+    const tag = resource.pluralLabel;
+    const plural = tag.replace(/(?:^|\s+)(\w)/g, (_, letter) => letter.toUpperCase());
+    tags.push({ name: tag, description: `The ${resource.pluralLabel.toLowerCase()} API, generated from resources/${resource.slug}.` });
+    const denied = { "401": problem2("Sign in first."), "403": problem2("Your role can't do this.") };
+    const collection = {};
+    const item = {};
+    const idParam = { name: "id", in: "path", required: true, schema: { type: "string" } };
+    if (can2("list")) {
+      collection.get = {
+        operationId: `list${plural}`,
+        tags: [tag],
+        summary: `List ${resource.pluralLabel.toLowerCase()}`,
+        description: rolesNote(policy, "list"),
+        parameters: listParameters(resource),
+        responses: { "200": { description: "One page of records.", content: json(ref(`${resource.name}Page`)) }, "400": problem2("A query parameter isn't accepted."), ...denied }
+      };
+    }
+    if (can2("create")) {
+      collection.post = {
+        operationId: `create${resource.name}`,
+        tags: [tag],
+        summary: `Create a ${resource.label.toLowerCase()}`,
+        description: rolesNote(policy, "create"),
+        requestBody: { required: true, content: json(ref(`${resource.name}Create`)) },
+        responses: {
+          "201": { description: "Created. The Location header points at it.", content: json(ref(resource.name)) },
+          "409": problem2("A unique field already has this value."),
+          "422": problem2("Validation failed; `issues` lists each field."),
+          ...denied
+        }
+      };
+    }
+    if (can2("read")) {
+      item.get = {
+        operationId: `get${resource.name}`,
+        tags: [tag],
+        summary: `Get a ${resource.label.toLowerCase()}`,
+        description: rolesNote(policy, "read"),
+        parameters: [idParam],
+        responses: { "200": { description: "The record.", content: json(ref(resource.name)) }, "404": problem2("No record with this id."), ...denied }
+      };
+    }
+    if (can2("update")) {
+      const body = (name) => ({ required: true, content: json(ref(name)) });
+      const responses = {
+        "200": { description: "The updated record.", content: json(ref(resource.name)) },
+        "404": problem2("No record with this id."),
+        "409": problem2("A unique field already has this value."),
+        "422": problem2("Validation failed; `issues` lists each field."),
+        ...denied
+      };
+      item.patch = { operationId: `update${resource.name}`, tags: [tag], summary: `Update a ${resource.label.toLowerCase()}`, description: `Send only the fields to change. ${rolesNote(policy, "update")}`, parameters: [idParam], requestBody: body(`${resource.name}Update`), responses };
+      item.put = { operationId: `replace${resource.name}`, tags: [tag], summary: `Replace a ${resource.label.toLowerCase()}`, description: `Send every field. ${rolesNote(policy, "update")}`, parameters: [idParam], requestBody: body(`${resource.name}Create`), responses };
+    }
+    if (can2("delete")) {
+      item.delete = {
+        operationId: `delete${resource.name}`,
+        tags: [tag],
+        summary: `Delete a ${resource.label.toLowerCase()}`,
+        description: rolesNote(policy, "delete"),
+        parameters: [idParam],
+        responses: { "204": { description: "Deleted." }, "404": problem2("No record with this id."), "409": problem2("Other records still point at this one."), ...denied }
+      };
+    }
+    if (Object.keys(collection).length) paths[`/api/${resource.slug}`] = collection;
+    if (Object.keys(item).length) paths[`/api/${resource.slug}/{id}`] = item;
+  }
+  const visible = tags.length - 1;
+  const intro = role === null && visibility === "role" ? "Sign in to see the endpoints available to you: use **Authentication \u2192 Sign in** below, or sign in to the app in this browser, then reload." : `${visible} resource API${visible === 1 ? "" : "s"} available to ${visibility === "public" ? "everyone" : `the **${role}** role`}.`;
+  return {
+    openapi: "3.1.0",
+    info: {
+      title: options.title ?? "API",
+      version: options.version ?? "1.0.0",
+      description: [options.description, intro, "Requests are authorized by the session cookie. Writes must be same-origin JSON (`Content-Type: application/json`)."].filter(Boolean).join("\n\n")
+    },
+    servers: options.serverUrl ? [{ url: options.serverUrl }] : void 0,
+    security: [{ session: [] }],
+    tags,
+    paths,
+    components: {
+      schemas,
+      securitySchemes: {
+        session: { type: "apiKey", in: "cookie", name: "better-auth.session_token", description: "Set by signing in. Browsers send it automatically on same-origin requests." }
+      }
+    }
+  };
+}
 export {
   createResourceHandlers,
   createResourceStore,
+  fieldJsonSchema,
   isFilterable,
   isSearchable,
   isSortable,
+  openApiDocument,
   parseListQuery
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flaredev/core",
-  "version": "0.1.2",
+  "version": "0.3.0",
   "description": "Flare runtime: resource descriptors, field grammar, and Cloudflare-native helpers",
   "license": "MIT",
   "author": "Muke Johnbaptist",
@@ -66,6 +66,7 @@
     "README.md"
   ],
   "dependencies": {
+    "libphonenumber-js": "1.13.13",
     "zod": "^4.6.5"
   },
   "devDependencies": {

package/dist/chunk-DARDHZPX.js

@@ -1,192 +0,0 @@
-// src/resource/naming.ts
-function words(value) {
-  return value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").split(/[^A-Za-z0-9]+/).filter(Boolean).map((word) => word.toLowerCase());
-}
-var pascalCase = (value) => words(value).map((w) => w[0].toUpperCase() + w.slice(1)).join("");
-var camelCase = (value) => {
-  const pascal = pascalCase(value);
-  return pascal ? pascal[0].toLowerCase() + pascal.slice(1) : pascal;
-};
-var snakeCase = (value) => words(value).join("_");
-var kebabCase = (value) => words(value).join("-");
-var humanize = (value) => {
-  const text = words(value).join(" ");
-  return text ? text[0].toUpperCase() + text.slice(1) : text;
-};
-var UNCOUNTABLE = /* @__PURE__ */ new Set(["equipment", "information", "rice", "money", "species", "series", "fish", "sheep", "data", "news"]);
-var IRREGULAR = { person: "people", man: "men", woman: "women", child: "children", mouse: "mice" };
-function pluralize(value) {
-  const match = /([A-Za-z]+)$/.exec(value);
-  if (!match) return value;
-  const word = match[1];
-  const lower = word.toLowerCase();
-  const head = value.slice(0, value.length - word.length);
-  const keepCase = (plural) => word[0] === word[0].toUpperCase() ? plural[0].toUpperCase() + plural.slice(1) : plural;
-  if (UNCOUNTABLE.has(lower)) return value;
-  if (IRREGULAR[lower]) return head + keepCase(IRREGULAR[lower]);
-  if (/[^aeiou]y$/i.test(word)) return head + word.slice(0, -1) + "ies";
-  if (/(s|x|z|ch|sh)$/i.test(word)) return head + word + "es";
-  return head + word + "s";
-}
-
-// src/resource/define.ts
-var RESERVED_FIELD_NAMES = ["id", "createdAt", "updatedAt"];
-var ResourceDefinitionError = class extends Error {
-  constructor(resource, message) {
-    super(`Resource "${resource}": ${message}`);
-    this.name = "ResourceDefinitionError";
-  }
-};
-var IDENTIFIER = /^[a-z][A-Za-z0-9]*$/;
-function defaultFieldLabel(key, field) {
-  return humanize(field.kind === "belongsTo" ? key.replace(/Id$/, "") : key);
-}
-function defineResource(config) {
-  const name = config.name;
-  const fail = (message) => {
-    throw new ResourceDefinitionError(name, message);
-  };
-  if (!/^[A-Z][A-Za-z0-9]*$/.test(name) || pascalCase(name) !== name) fail('name must be PascalCase, e.g. "OrderItem".');
-  const entries = Object.entries(config.fields);
-  if (entries.length === 0) fail("define at least one field.");
-  const fields = {};
-  for (const [key, def] of entries) {
-    if (!IDENTIFIER.test(key)) fail(`field "${key}" must be camelCase (letters and digits, starting lowercase).`);
-    if (RESERVED_FIELD_NAMES.includes(key)) fail(`"${key}" is added automatically; don't declare it.`);
-    if (def.kind === "enum") {
-      if (def.options.length === 0) fail(`enum field "${key}" needs at least one option.`);
-      if (new Set(def.options).size !== def.options.length) fail(`enum field "${key}" has duplicate options.`);
-      if (def.default !== void 0 && !def.options.includes(def.default)) fail(`default of "${key}" isn't one of its options.`);
-    }
-    if (def.kind === "belongsTo" && !key.endsWith("Id")) fail(`belongsTo field "${key}" must end in "Id", e.g. "${camelCase(def.target)}Id".`);
-    if ((def.kind === "belongsTo" || def.kind === "hasMany") && pascalCase(def.target) !== def.target) {
-      fail(`relation "${key}" must target a PascalCase resource name.`);
-    }
-    if (def.kind === "belongsTo" && def.onDelete === "set null" && def.required) {
-      fail(`"${key}" uses onDelete "set null" but is required; mark it required: false.`);
-    }
-    if (def.kind === "file" && def.accept.length === 0) fail(`file field "${key}" must accept at least one category.`);
-    fields[key] = { ...def, label: def.label ?? defaultFieldLabel(key, def) };
-  }
-  const stored = entries.filter(([, def]) => def.kind !== "hasMany");
-  const titleField = config.titleField ?? stored.find(([, def]) => def.kind === "string")?.[0] ?? stored[0]?.[0] ?? "id";
-  if (config.titleField && !stored.some(([key]) => key === config.titleField)) {
-    fail(`titleField "${config.titleField}" isn't a stored field.`);
-  }
-  const defaultSort = config.defaultSort ?? { field: "createdAt", direction: "desc" };
-  if (!["createdAt", "updatedAt"].includes(defaultSort.field) && !stored.some(([key]) => key === defaultSort.field)) {
-    fail(`defaultSort field "${defaultSort.field}" isn't a stored field.`);
-  }
-  const perPage = config.perPage ?? 25;
-  if (!Number.isInteger(perPage) || perPage < 1 || perPage > 100) fail("perPage must be an integer from 1 to 100.");
-  const pluralName = pluralize(name);
-  return {
-    name,
-    table: config.table ?? snakeCase(pluralName),
-    slug: config.slug ?? kebabCase(pluralName),
-    label: config.label ?? humanize(name),
-    pluralLabel: config.pluralLabel ?? humanize(pluralName),
-    icon: config.icon,
-    titleField,
-    defaultSort,
-    perPage,
-    fields,
-    $types: void 0
-  };
-}
-function storedFields(resource) {
-  return Object.entries(resource.fields).filter(([, def]) => def.kind !== "hasMany");
-}
-var columnName = (key) => snakeCase(key);
-
-// src/resource/validators.ts
-import { z } from "zod";
-var DEFAULT_STRING_MAX = 255;
-var DEFAULT_TEXT_MAX = 65535;
-var OBJECT_KEY = /^(?!\/)(?!.*(?:^|\/)\.\.(?:\/|$)).{1,1024}$/;
-var typeError = (message) => (issue) => issue.input === void 0 || issue.input === null || issue.input === "" ? "Required" : message;
-function stringSchema(max, min, required) {
-  let s = z.string({ error: typeError("Enter text") });
-  if (max) s = s.max(max, `At most ${max} characters`);
-  if (min !== void 0) s = s.min(min, min === 1 ? "Required" : `At least ${min} characters`);
-  else if (required) s = s.min(1, "Required");
-  return s;
-}
-function fieldSchema(def) {
-  switch (def.kind) {
-    case "string": {
-      let s = z.string({ error: typeError("Enter text") }).trim().max(def.maxLength ?? DEFAULT_STRING_MAX, `At most ${def.maxLength ?? DEFAULT_STRING_MAX} characters`);
-      if (def.minLength !== void 0) s = s.min(def.minLength, `At least ${def.minLength} characters`);
-      else if (def.required) s = s.min(1, "Required");
-      if (def.pattern) s = s.regex(new RegExp(def.pattern), "Invalid format");
-      if (def.format === "email") return s.pipe(z.email({ error: "Enter a valid email address" }));
-      if (def.format === "url") return s.pipe(z.url({ protocol: /^https?$/, error: "Enter a valid URL (http or https)" }));
-      return s;
-    }
-    case "text":
-      return stringSchema(def.maxLength ?? DEFAULT_TEXT_MAX, def.minLength, def.required);
-    case "int":
-    case "float": {
-      let s = z.number({ error: typeError("Enter a number") });
-      if (def.kind === "int") s = s.int("Enter a whole number");
-      if (def.min !== void 0) s = s.min(def.min, `Must be at least ${def.min}`);
-      if (def.max !== void 0) s = s.max(def.max, `Must be at most ${def.max}`);
-      return s;
-    }
-    case "boolean":
-      return z.boolean({ error: typeError("Choose yes or no") });
-    case "date":
-      return z.iso.date({ error: typeError("Enter a valid date") });
-    case "datetime":
-      return z.iso.datetime({ offset: true, error: typeError("Enter a valid date and time") });
-    case "enum":
-      return z.enum(def.options, { error: typeError("Choose one of the options") });
-    case "file":
-      return z.string({ error: typeError("Upload a file") }).regex(OBJECT_KEY, "Invalid file");
-    case "belongsTo":
-      return z.string({ error: typeError("Choose a record") }).min(1, "Required");
-  }
-}
-var fileKeyPrefix = (resource, fieldKey) => `${resource.table}/${fieldKey}/`;
-function createValidators(resource) {
-  const create = {};
-  const update = {};
-  for (const [key, def] of storedFields(resource)) {
-    let base = fieldSchema(def);
-    if (def.kind === "file") {
-      const prefix = fileKeyPrefix(resource, key);
-      base = base.refine(
-        (value2) => typeof value2 !== "string" || !OBJECT_KEY.test(value2) || value2.startsWith(prefix),
-        "This file wasn't uploaded for this field"
-      );
-    }
-    const value = def.required ? base : base.nullable();
-    update[key] = value.optional();
-    const hasDefault = "default" in def && def.default !== void 0;
-    create[key] = def.required && !hasDefault ? value : value.optional();
-  }
-  const unknownKeys = { error: (issue) => issue.code === "unrecognized_keys" ? `Unknown field(s): ${issue.keys?.join(", ")}` : void 0 };
-  return {
-    create: z.strictObject(create, unknownKeys),
-    update: z.strictObject(update, unknownKeys)
-  };
-}
-
-export {
-  words,
-  pascalCase,
-  camelCase,
-  snakeCase,
-  kebabCase,
-  humanize,
-  pluralize,
-  RESERVED_FIELD_NAMES,
-  ResourceDefinitionError,
-  defaultFieldLabel,
-  defineResource,
-  storedFields,
-  columnName,
-  fieldSchema,
-  fileKeyPrefix,
-  createValidators
-};