@flaredev/core 0.1.0

package/dist/client.js

@@ -0,0 +1,52 @@
+// src/client.ts
+var ApiError = class extends Error {
+  status;
+  issues;
+  field;
+  constructor(status, body) {
+    super(body?.error ?? `Request failed with status ${status}`);
+    this.name = "ApiError";
+    this.status = status;
+    this.issues = body?.issues ?? [];
+    this.field = body?.field;
+  }
+};
+function createResourceClient(path, options = {}) {
+  const doFetch = options.fetch ?? ((input, init) => fetch(input, init));
+  const root = `${options.baseURL?.replace(/\/+$/, "") ?? ""}${path.replace(/\/+$/, "")}`;
+  async function request(url, init = {}) {
+    const headers = new Headers(options.headers);
+    new Headers(init.headers).forEach((value, key) => headers.set(key, value));
+    if (init.body !== void 0) headers.set("content-type", "application/json");
+    headers.set("accept", "application/json");
+    const response = await doFetch(url, { credentials: "same-origin", ...init, headers });
+    if (response.status === 204) return void 0;
+    const body = await response.json().catch(() => null);
+    if (!response.ok) throw new ApiError(response.status, body);
+    return body;
+  }
+  const itemUrl = (id) => `${root}/${encodeURIComponent(id)}`;
+  return {
+    list(params = {}) {
+      const search = new URLSearchParams();
+      if (params.page !== void 0) search.set("page", String(params.page));
+      if (params.perPage !== void 0) search.set("perPage", String(params.perPage));
+      if (params.sort) search.set("sort", params.sort);
+      if (params.q) search.set("q", params.q);
+      for (const [key, value] of Object.entries(params.filter ?? {})) search.set(`filter[${key}]`, String(value));
+      const query = search.toString();
+      return request(query ? `${root}?${query}` : root);
+    },
+    get: (id) => request(itemUrl(id)),
+    create: (input) => request(root, { method: "POST", body: JSON.stringify(input) }),
+    /** Partial update (PATCH). */
+    update: (id, input) => request(itemUrl(id), { method: "PATCH", body: JSON.stringify(input) }),
+    /** Full replacement (PUT): omitted optional fields are cleared. */
+    replace: (id, input) => request(itemUrl(id), { method: "PUT", body: JSON.stringify(input) }),
+    delete: (id) => request(itemUrl(id), { method: "DELETE" })
+  };
+}
+export {
+  ApiError,
+  createResourceClient
+};

package/dist/define-D5CtCkOm.d.ts

@@ -0,0 +1,232 @@
+/**
+ * Field builders for resource descriptors.
+ *
+ * Every builder returns a plain, serializable object. The API layer, admin UI and
+ * generator all read these objects at runtime, so changing a label or a validation
+ * 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" | "file" | "belongsTo" | "hasMany";
+/** Options shared by every stored (non-hasMany) field. */
+interface CommonOptions<T> {
+    label?: string;
+    /** Required fields must be present on create and can't be null. Default true. */
+    required?: boolean;
+    unique?: boolean;
+    /** Used when the field is omitted on create (also written as the column default). */
+    default?: T;
+    helpText?: string;
+    placeholder?: string;
+    /** Show as a column in list views. Default true for most kinds, false for long text. */
+    list?: boolean;
+    sortable?: boolean;
+    filterable?: boolean;
+    /** Included in free-text search. Default true for string fields. */
+    searchable?: boolean;
+}
+interface StringOptions extends CommonOptions<string> {
+    maxLength?: number;
+    minLength?: number;
+    format?: "email" | "url";
+    pattern?: string;
+}
+interface TextOptions extends CommonOptions<string> {
+    maxLength?: number;
+    minLength?: number;
+}
+interface NumberOptions extends CommonOptions<number> {
+    min?: number;
+    max?: number;
+}
+type BooleanOptions = CommonOptions<boolean>;
+type DateOptions = CommonOptions<string>;
+interface EnumOptions<O extends string> extends CommonOptions<O> {
+    /** Display labels per option value. */
+    optionLabels?: Partial<Record<O, string>>;
+}
+interface FileOptions extends CommonOptions<string> {
+    /** Maximum upload size in bytes. Default 10 MiB. */
+    maxBytes?: number;
+}
+interface BelongsToOptions extends Omit<CommonOptions<string>, "default" | "unique"> {
+    /** What happens to this record when the parent is deleted. Default "restrict". */
+    onDelete?: "cascade" | "restrict" | "set null";
+    unique?: boolean;
+}
+interface HasManyOptions {
+    label?: string;
+    /** The belongsTo field on the related resource pointing back here. Default: camelCase of this resource's name. */
+    foreignKey?: string;
+}
+type Req<O> = O extends {
+    required: false;
+} ? false : true;
+interface Base<K extends FieldKind, R extends boolean> {
+    kind: K;
+    required: R;
+}
+type StringField<R extends boolean = boolean> = Base<"string", R> & StringOptions;
+type TextField<R extends boolean = boolean> = Base<"text", R> & TextOptions;
+type IntField<R extends boolean = boolean> = Base<"int", R> & NumberOptions;
+type FloatField<R extends boolean = boolean> = Base<"float", R> & NumberOptions;
+type BooleanField<R extends boolean = boolean> = Base<"boolean", R> & BooleanOptions;
+type DateField<R extends boolean = boolean> = Base<"date", R> & DateOptions;
+type DateTimeField<R extends boolean = boolean> = Base<"datetime", R> & DateOptions;
+type EnumField<O extends string = string, R extends boolean = boolean> = Base<"enum", R> & EnumOptions<O> & {
+    options: readonly O[];
+};
+type FileField<R extends boolean = boolean> = Base<"file", R> & FileOptions & {
+    /** Accepted categories from the `file:[image,pdf]` grammar. */
+    accept: readonly FileCategory[];
+};
+type BelongsToField<R extends boolean = boolean> = Base<"belongsTo", R> & BelongsToOptions & {
+    /** PascalCase name of the related resource. */
+    target: string;
+};
+type HasManyField = {
+    kind: "hasMany";
+    required: false;
+    target: string;
+} & HasManyOptions;
+type Field = StringField | TextField | IntField | FloatField | BooleanField | DateField | DateTimeField | EnumField | FileField | BelongsToField | HasManyField;
+type StoredField = Exclude<Field, HasManyField>;
+/** File categories usable in `file:[...]` and the MIME types each allows. */
+declare const FILE_CATEGORIES: {
+    readonly image: readonly ["image/png", "image/jpeg", "image/gif", "image/webp", "image/avif"];
+    readonly pdf: readonly ["application/pdf"];
+    readonly video: readonly ["video/*"];
+    readonly audio: readonly ["audio/*"];
+    readonly text: readonly ["text/plain"];
+    readonly csv: readonly ["text/csv"];
+    readonly document: readonly ["application/msword", "application/vnd.openxmlformats-officedocument.wordprocessingml.document", "application/vnd.oasis.opendocument.text"];
+    readonly spreadsheet: readonly ["application/vnd.ms-excel", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "application/vnd.oasis.opendocument.spreadsheet"];
+    readonly archive: readonly ["application/zip"];
+};
+type FileCategory = keyof typeof FILE_CATEGORIES;
+declare function mimeTypesFor(accept: readonly FileCategory[]): string[];
+/** Upload limit for file fields without an explicit `maxBytes` (10 MB). */
+declare const DEFAULT_FILE_MAX_BYTES: number;
+/** The upload limit a file field enforces. */
+declare const fileMaxBytes: (field: {
+    maxBytes?: number;
+}) => number;
+declare const field: {
+    string: <const O extends StringOptions>(options?: O) => StringField<Req<O>> & O;
+    text: <const O extends TextOptions>(options?: O) => TextField<Req<O>> & O;
+    int: <const O extends NumberOptions>(options?: O) => IntField<Req<O>> & O;
+    float: <const O extends NumberOptions>(options?: O) => FloatField<Req<O>> & O;
+    boolean: <const O extends BooleanOptions>(options?: O) => BooleanField<Req<O>> & O;
+    date: <const O extends DateOptions>(options?: O) => DateField<Req<O>> & O;
+    datetime: <const O extends DateOptions>(options?: O) => DateTimeField<Req<O>> & O;
+    enum: <const V extends readonly [string, ...string[]], const O extends EnumOptions<V[number]>>(values: V, options?: O) => EnumField<V[number], Req<O>> & O;
+    file: <const O extends FileOptions>(accept: readonly FileCategory[], options?: O) => FileField<Req<O>> & O;
+    belongsTo: <const O extends BelongsToOptions>(target: string, options?: O) => BelongsToField<Req<O>> & O;
+    hasMany: <const O extends HasManyOptions>(target: string, options?: O) => HasManyField & O;
+};
+type FieldValue<F> = F extends {
+    kind: "int" | "float";
+} ? number : F extends {
+    kind: "boolean";
+} ? boolean : F extends {
+    kind: "enum";
+    options: readonly (infer O)[];
+} ? O : F extends {
+    kind: "hasMany";
+} ? never : string;
+type StoredKeys<Fields> = {
+    [K in keyof Fields]: Fields[K] extends {
+        kind: "hasMany";
+    } ? never : K;
+}[keyof Fields];
+type RequiredOnCreate<Fields> = {
+    [K in StoredKeys<Fields>]: Fields[K] extends {
+        required: true;
+    } ? (Fields[K] extends {
+        default: unknown;
+    } ? never : K) : never;
+}[StoredKeys<Fields>];
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+/** Body accepted when creating a record. */
+type CreateInput<Fields> = Simplify<{
+    [K in RequiredOnCreate<Fields>]: FieldValue<Fields[K]>;
+} & {
+    [K in Exclude<StoredKeys<Fields>, RequiredOnCreate<Fields>>]?: Fields[K] extends {
+        required: true;
+    } ? FieldValue<Fields[K]> : FieldValue<Fields[K]> | null;
+}>;
+/** Body accepted when updating a record (PATCH semantics: every field optional). */
+type UpdateInput<Fields> = Partial<CreateInput<Fields>>;
+/** A record as returned by the JSON API. */
+type RecordOf<Fields> = Simplify<{
+    id: string;
+    createdAt: string;
+    updatedAt: string;
+} & {
+    [K in StoredKeys<Fields>]: Fields[K] extends {
+        required: true;
+    } ? FieldValue<Fields[K]> : FieldValue<Fields[K]> | null;
+}>;
+
+declare const RESERVED_FIELD_NAMES: readonly ["id", "createdAt", "updatedAt"];
+type FieldKey<Fields> = Extract<keyof Fields, string>;
+interface ResourceConfig<Fields extends Record<string, Field>> {
+    /** PascalCase singular name, e.g. "Contact", "OrderItem". */
+    name: string;
+    fields: Fields;
+    /** Database table. Default: snake_case plural ("order_items"). */
+    table?: string;
+    /** URL segment for the API and admin. Default: kebab-case plural ("order-items"). */
+    slug?: string;
+    label?: string;
+    pluralLabel?: string;
+    /** lucide-react icon name for navigation, e.g. "users". Default: a generic document icon. */
+    icon?: string;
+    /** Field used to represent a record in lists and relation pickers. Default: first string field. */
+    titleField?: FieldKey<Fields>;
+    defaultSort?: {
+        field: FieldKey<Fields> | "createdAt" | "updatedAt";
+        direction: "asc" | "desc";
+    };
+    /** Page size for list endpoints and tables. Default 25. */
+    perPage?: number;
+}
+interface Resource<Fields extends Record<string, Field> = Record<string, Field>> {
+    name: string;
+    table: string;
+    slug: string;
+    label: string;
+    pluralLabel: string;
+    icon: string | undefined;
+    titleField: string;
+    defaultSort: {
+        field: string;
+        direction: "asc" | "desc";
+    };
+    perPage: number;
+    /** Fields with labels filled in. */
+    fields: Fields & Record<string, Field & {
+        label: string;
+    }>;
+    /** Type-only helpers: `typeof contact.$types.record`. Always undefined at runtime. */
+    $types: {
+        create: CreateInput<Fields>;
+        update: UpdateInput<Fields>;
+        record: RecordOf<Fields>;
+    };
+}
+declare class ResourceDefinitionError extends Error {
+    constructor(resource: string, message: string);
+}
+/** Label for a field key; belongsTo keys drop their "Id" suffix ("companyId" → "Company"). */
+declare function defaultFieldLabel(key: string, field: Field): string;
+declare function defineResource<const Fields extends Record<string, Field>>(config: ResourceConfig<Fields>): Resource<Fields>;
+/** Stored (column-backed) fields of a resource, in declaration order. */
+declare function storedFields(resource: Resource): [string, StoredField & {
+    label: string;
+}][];
+/** Database column name for a field key ("companyId" → "company_id"). */
+declare const columnName: (key: string) => string;
+
+export { type BelongsToField as B, type CreateInput as C, DEFAULT_FILE_MAX_BYTES as D, type EnumField as E, type Field as F, type HasManyField as H, type IntField as I, type Resource as R, type StoredField as S, type TextField as T, type UpdateInput as U, type BooleanField as a, type DateField as b, type DateTimeField as c, FILE_CATEGORIES as d, type FieldKind as e, type FieldValue as f, type FileCategory as g, type FileField as h, type FloatField as i, RESERVED_FIELD_NAMES as j, type RecordOf as k, type ResourceConfig as l, ResourceDefinitionError as m, type StringField as n, columnName as o, defaultFieldLabel as p, defineResource as q, field as r, fileMaxBytes as s, mimeTypesFor as t, storedFields as u };