@murumets-ee/entity 0.1.0

package/LICENSE

@@ -0,0 +1,94 @@
+Elastic License 2.0 (ELv2)
+
+URL: https://www.elastic.co/licensing/elastic-license
+
+## Acceptance
+
+By using the software, you agree to all of the terms and conditions below.
+
+## Copyright License
+
+The licensor grants you a non-exclusive, royalty-free, worldwide,
+non-sublicensable, non-transferable license to use, copy, distribute, make
+available, and prepare derivative works of the software, in each case subject
+to the limitations and conditions below.
+
+## Limitations
+
+You may not provide the software to third parties as a hosted or managed
+service, where the service provides users with access to any substantial set
+of the features or functionality of the software.
+
+You may not move, change, disable, or circumvent the license key functionality
+in the software, and you may not remove or obscure any functionality in the
+software that is protected by the license key.
+
+You may not alter, remove, or obscure any licensing, copyright, or other
+notices of the licensor in the software. Any use of the licensor's trademarks
+is subject to applicable law.
+
+## Patents
+
+The licensor grants you a license, under any patent claims the licensor can
+license, or becomes able to license, to make, have made, use, sell, offer for
+sale, import and have imported the software, in each case subject to the
+limitations and conditions in this license. This license does not cover any
+patent claims that you cause to be infringed by modifications or additions to
+the software. If you or your company make any written claim that the software
+infringes or contributes to infringement of any patent, your patent license
+for the software granted under these terms ends immediately. If your company
+makes such a claim, your patent license ends immediately for work on behalf
+of your company.
+
+## Notices
+
+You must ensure that anyone who gets a copy of any part of the software from
+you also gets a copy of these terms.
+
+If you modify the software, you must include in any modified copies of the
+software prominent notices stating that you have modified the software.
+
+## No Other Rights
+
+These terms do not imply any licenses other than those expressly granted in
+these terms.
+
+## Termination
+
+If you use the software in violation of these terms, such use is not licensed,
+and your licenses will automatically terminate. If the licensor provides you
+with a notice of your violation, and you cease all violation of this license
+no later than 30 days after you receive that notice, your licenses will be
+reinstated retroactively. However, if you violate these terms after such
+reinstatement, any additional violation of these terms will cause your
+licenses to terminate automatically and permanently.
+
+## No Liability
+
+As far as the law allows, the software comes as is, without any warranty or
+condition, and the licensor will not be liable to you for any damages arising
+out of these terms or the use or nature of the software, under any kind of
+legal claim.
+
+## Definitions
+
+The **licensor** is the entity offering these terms, and the **software** is
+the software the licensor makes available under these terms, including any
+portion of it.
+
+**you** refers to the individual or entity agreeing to these terms.
+
+**your company** is any legal entity, sole proprietorship, or other kind of
+organization that you work for, plus all organizations that have control over,
+are under the control of, or are under common control with that organization.
+**control** means ownership of substantially all the assets of an entity, or
+the power to direct the management and policies of an entity (for example, by
+voting right, contract, or otherwise). Control can be direct or indirect.
+
+**your licenses** are all the licenses granted to you for the software under
+these terms.
+
+**use** means anything you do with the software requiring one of your
+licenses.
+
+**trademark** means trademarks, service marks, and similar rights.

package/README.md

@@ -0,0 +1,15 @@
+# @murumets-ee/entity
+
+Entity definition, field builders, behaviors, admin client, query client, and schema generation.
+
+Part of [Lumi CMS](https://github.com/murumets-ee/lumi-cms) — a modular, type-safe CMS toolkit for Node.js.
+
+## Install
+
+```bash
+npm install @murumets-ee/entity
+```
+
+## License
+
+[Elastic License 2.0 (ELv2)](../../LICENSE)

package/dist/admin/index.d.ts

@@ -0,0 +1,510 @@
+import { SQL } from 'drizzle-orm';
+import { PostgresJsDatabase } from 'drizzle-orm/postgres-js';
+
+/**
+ * In-memory TTL cache for COUNT(*) query results.
+ *
+ * Reduces database load on paginated list pages where the total count
+ * is recalculated on every pagination/sort/search interaction. The cache
+ * is per-process (not shared across workers) with a short TTL (default 5s)
+ * so counts are at most a few seconds stale.
+ *
+ * Cache keys include the entity name + serialized WHERE clause, so filtered
+ * and unfiltered counts are cached independently.
+ */
+/**
+ * Interface for count cache implementations.
+ * Used in client configs to avoid TypeScript private-field structural incompatibility
+ * across separate .d.ts files.
+ */
+interface CountCacheLike {
+    get(key: string): number | undefined;
+    set(key: string, count: number): void;
+    invalidate(prefix: string): void;
+}
+
+/**
+ * Cursor-based (keyset) pagination utilities.
+ *
+ * Cursor pagination avoids the performance cliff of OFFSET at scale (1M+ rows).
+ * Instead of `OFFSET N`, it uses a WHERE condition:
+ *   `WHERE (sortField < lastValue) OR (sortField = lastValue AND id < lastId)`
+ * which Postgres can serve from an index in constant time.
+ *
+ * The cursor is opaque to the client — base64-encoded JSON.
+ *
+ * Security:
+ * - `field` must be whitelisted against the entity's actual fields
+ * - `id` must be a valid UUID
+ * - `value` is parameterized (never interpolated into SQL)
+ * - Malformed cursors return null (caller returns 400)
+ */
+
+/** Cursor input for keyset pagination. */
+interface CursorInput {
+    /** Sort field name (e.g. 'createdAt'). Must be a real column on the entity. */
+    field: string;
+    /** Last seen value of the sort field. */
+    value: string | number;
+    /** Sort direction — must match the ORDER BY direction. */
+    direction: 'asc' | 'desc';
+    /** Tie-breaker: last seen entity ID. Required for non-unique sort fields. */
+    id?: string;
+}
+
+/**
+ * Optional admin UI configuration for entities.
+ * Controls how entities appear in the admin sidebar, list pages, and forms.
+ */
+interface EntityAdminConfig {
+    /** Sidebar section: 'content' | 'structure' | custom string. Default: 'content' */
+    group?: string;
+    /** Plural display name for sidebar + list pages. Default: title-cased pluralized entity name */
+    label?: string;
+    /** Singular label for "New X" button. Default: title-cased entity name */
+    labelSingular?: string;
+    /** Lucide icon name as string, e.g. 'file-text' */
+    icon?: string;
+    /** Description shown on list page */
+    description?: string;
+    /** Form layout. Default: 'single' */
+    layout?: 'single' | 'two-column';
+    /** Fields to hide in the form */
+    hiddenFields?: string[];
+    /** Columns to hide in the list */
+    hiddenColumns?: string[];
+    /** Per-field label/description/placeholder overrides */
+    fieldOverrides?: Record<string, {
+        label?: string;
+        description?: string;
+        placeholder?: string;
+    }>;
+    /** Default list sort field. Default: 'createdAt' */
+    defaultSort?: string;
+    /** Default list sort direction. Default: 'desc' */
+    defaultSortDirection?: 'asc' | 'desc';
+    /** List page size. Default: 20 */
+    pageSize?: number;
+    /** For block editor: fields to show in Puck root config */
+    rootFields?: string[];
+    /** Suppress "New" button in the list page */
+    disableCreate?: boolean;
+    /** Order within sidebar group. Default: 0 */
+    sortOrder?: number;
+}
+
+/**
+ * Field type definitions
+ * These define the structure and configuration for all field types
+ */
+interface BaseFieldConfig {
+    required?: boolean;
+    default?: unknown;
+    translatable?: boolean;
+    indexed?: boolean;
+    unique?: boolean;
+    access?: {
+        view?: string;
+        edit?: string;
+    };
+}
+interface IdField extends BaseFieldConfig {
+    type: 'id';
+}
+interface TextField extends BaseFieldConfig {
+    type: 'text';
+    maxLength?: number;
+    minLength?: number;
+    pattern?: RegExp;
+}
+interface NumberField extends BaseFieldConfig {
+    type: 'number';
+    min?: number;
+    max?: number;
+    integer?: boolean;
+}
+interface BooleanField extends BaseFieldConfig {
+    type: 'boolean';
+}
+interface DateField extends BaseFieldConfig {
+    type: 'date';
+    minDate?: Date;
+    maxDate?: Date;
+}
+interface SelectField extends BaseFieldConfig {
+    type: 'select';
+    options: readonly string[];
+}
+interface ReferenceField extends BaseFieldConfig {
+    type: 'reference';
+    entity: string;
+    cardinality: 'one' | 'many';
+    onDelete?: 'cascade' | 'set-null' | 'restrict';
+}
+interface MediaField extends BaseFieldConfig {
+    type: 'media';
+    accept?: string[];
+    maxSize?: number;
+}
+interface RichTextField extends BaseFieldConfig {
+    type: 'richtext';
+    blocks?: string[];
+}
+interface SlugField extends BaseFieldConfig {
+    type: 'slug';
+    from: string;
+    unique?: boolean;
+}
+/**
+ * Minimal block definition reference — used by BlocksField to type-check allowed blocks.
+ * The full BlockDefinition (with label, etc.) lives in @murumets-ee/content.
+ */
+interface BlockDefinitionRef {
+    slug: string;
+    fields: Record<string, FieldConfig>;
+}
+/**
+ * Blocks field — ordered array of typed content blocks.
+ * Each block instance stores its data in {entity}_layout table.
+ *
+ * @property blocks - Allowed block definitions
+ * @property min/max - Block count constraints
+ * @property localized - true = per-locale layouts, false = shared layout with translated content (default)
+ */
+interface JsonField extends BaseFieldConfig {
+    type: 'json';
+}
+interface BlocksField extends BaseFieldConfig {
+    type: 'blocks';
+    blocks: readonly BlockDefinitionRef[];
+    min?: number;
+    max?: number;
+    localized?: boolean;
+}
+type FieldConfig = IdField | TextField | NumberField | BooleanField | DateField | SelectField | ReferenceField | MediaField | RichTextField | SlugField | JsonField | BlocksField;
+
+/**
+ * Behavior system
+ * Behaviors add common functionality to entities (fields + hooks)
+ *
+ * @typeParam F - The field map this behavior contributes. Defaults to
+ *               Record<string, FieldConfig> for backward compatibility.
+ */
+
+interface Behavior<F extends Record<string, FieldConfig> = Record<string, FieldConfig>> {
+    name: string;
+    fields?: F;
+    hooks?: {
+        beforeCreate?: (data: Record<string, unknown>) => Promise<Record<string, unknown>>;
+        afterCreate?: (entity: Record<string, unknown>) => Promise<void>;
+        beforeUpdate?: (id: string, data: Record<string, unknown>) => Promise<Record<string, unknown>>;
+        afterUpdate?: (entity: Record<string, unknown>) => Promise<void>;
+        beforeDelete?: (id: string) => Promise<void>;
+        afterDelete?: (id: string) => Promise<void>;
+    };
+}
+
+/**
+ * Entity definition API
+ * The core function for defining entities with full type inference.
+ *
+ * The generic parameters are inferred from the call site:
+ * - F is inferred from `definition.fields`
+ * - B is inferred from `definition.behaviors` (as a tuple)
+ *
+ * The returned Entity carries the complete field map:
+ * { id: IdField } & BehaviorFields & UserFields
+ */
+
+/**
+ * A fully resolved entity with merged behavior fields.
+ * @typeParam AllFields - The complete field map (id + behaviors + user fields).
+ */
+interface Entity<AllFields extends Record<string, FieldConfig> = Record<string, FieldConfig>> {
+    name: string;
+    kind?: 'collection' | 'singleton';
+    fields: Record<string, FieldConfig>;
+    behaviors?: Behavior[];
+    scope?: 'global' | 'team' | 'user';
+    access?: {
+        view?: string;
+        create?: string;
+        update?: string;
+        delete?: string;
+    };
+    /** Admin UI configuration — controls sidebar, list, and form display */
+    admin?: EntityAdminConfig;
+    allFields: AllFields;
+    hooks: Behavior['hooks'];
+}
+
+/**
+ * Type inference utilities for the entity system.
+ * Maps field configurations to TypeScript types at compile time.
+ *
+ * Design principles:
+ * - Keep type nesting shallow (no recursive types beyond bounded tuple walking)
+ * - Use intermediate aliases to aid TS performance
+ * - All types are pure — zero runtime footprint
+ *
+ * Usage:
+ *   const Article = defineEntity({ ... })
+ *   type ArticleDTO = InferEntity<typeof Article>
+ */
+
+/**
+ * Maps a single FieldConfig to its TypeScript output type.
+ * Each branch is a shallow comparison — no recursion.
+ */
+type FieldToTS<F extends FieldConfig> = F extends IdField ? string : F extends TextField ? string : F extends NumberField ? number : F extends BooleanField ? boolean : F extends DateField ? Date | string : F extends SelectField ? F['options'][number] : F extends ReferenceField ? F['cardinality'] extends 'many' ? string[] : string : F extends MediaField ? string : F extends RichTextField ? Record<string, unknown>[] : F extends SlugField ? string : F extends JsonField ? Record<string, unknown> : F extends BlocksField ? Array<{
+    _block: string;
+    _id: string;
+    [key: string]: unknown;
+}> : never;
+/**
+ * Extract keys of fields where `required` is literally `true`.
+ * Fields without `required` or with `required?: false` are optional.
+ */
+type RequiredFieldKeys<Fields extends Record<string, FieldConfig>> = {
+    [K in keyof Fields]: Fields[K]['required'] extends true ? K : never;
+}[keyof Fields];
+type OptionalFieldKeys<Fields extends Record<string, FieldConfig>> = {
+    [K in keyof Fields]: Fields[K]['required'] extends true ? never : K;
+}[keyof Fields];
+/**
+ * Maps a full field record to its TypeScript output type.
+ * Required fields are non-nullable; optional fields are `T | null | undefined`.
+ *
+ * The `id` field is always `string` and always present.
+ * The `id` key from Fields is excluded to avoid duplication since
+ * we hardcode `{ id: string }` at the front.
+ */
+type InferEntityDTO<Fields extends Record<string, FieldConfig>> = {
+    id: string;
+} & {
+    [K in Exclude<RequiredFieldKeys<Fields>, 'id'>]: FieldToTS<Fields[K]>;
+} & {
+    [K in OptionalFieldKeys<Fields>]?: FieldToTS<Fields[K]> | null;
+};
+/** Fields that are auto-generated and should not appear in create input. */
+type AutoGeneratedFields = 'id' | 'createdAt' | 'updatedAt' | 'createdBy' | 'updatedBy' | '_version';
+/**
+ * The input type for creating an entity.
+ * - Omits auto-generated fields (id, timestamps, version)
+ * - Required fields stay required; optional fields stay optional
+ */
+type InferCreateInput<Fields extends Record<string, FieldConfig>> = Omit<{
+    [K in Exclude<RequiredFieldKeys<Fields>, 'id'>]: FieldToTS<Fields[K]>;
+} & {
+    [K in OptionalFieldKeys<Fields>]?: FieldToTS<Fields[K]> | null;
+}, AutoGeneratedFields>;
+/** Fields that cannot be changed after creation. */
+type ImmutableFields = 'id' | 'createdAt' | 'createdBy';
+type InferUpdateInput<Fields extends Record<string, FieldConfig>> = Partial<Omit<InferEntityDTO<Fields>, ImmutableFields>>;
+
+/**
+ * Minimal logger interface compatible with Pino.
+ *
+ * Defined locally to avoid a circular build dependency:
+ * entity → logging → core → entity.
+ *
+ * Any Pino logger instance satisfies this interface via structural typing.
+ */
+interface Logger {
+    info(obj: Record<string, unknown>, msg: string): void;
+    debug?(obj: Record<string, unknown>, msg: string): void;
+}
+
+/**
+ * AdminClient - Full CRUD with server-only enforcement
+ * CRITICAL: This file MUST NOT be imported in client code
+ */
+
+interface AdminClientConfig<AllFields extends Record<string, FieldConfig> = Record<string, FieldConfig>> {
+    entity: Entity<AllFields>;
+    db: PostgresJsDatabase;
+    logger?: Logger;
+    /** Optional count cache for COUNT(*) query optimization. */
+    countCache?: CountCacheLike;
+}
+interface FindManyOptions {
+    where?: SQL | undefined;
+    limit?: number;
+    offset?: number;
+    orderBy?: SQL | SQL[];
+    locale?: string;
+    /** Default content locale. For localized blocks, NULL rows (from initial create)
+     *  are only returned as fallback when locale matches defaultLocale. */
+    defaultLocale?: string;
+    /**
+     * Cursor-based (keyset) pagination. When provided, replaces OFFSET with a
+     * WHERE condition for O(1) page access at any depth. The `offset` option
+     * is ignored when `cursor` is set.
+     *
+     * The cursor `field` must be a real column on the entity table.
+     */
+    cursor?: CursorInput;
+}
+interface CountOptions {
+    where?: SQL | undefined;
+}
+/**
+ * AdminClient - Full CRUD operations with security enforcement
+ *
+ * Security layers:
+ * 1. Runtime check: typeof window !== 'undefined' → throw (allows CLI scripts)
+ * 2. Uses read-write DB connection
+ * 3. Validation with Zod before every write
+ * 4. Hook execution (beforeCreate, afterCreate, etc.)
+ *
+ * Note: We don't use 'server-only' import because it blocks CLI scripts.
+ * Next.js bundler protection comes from subpath exports (@murumets-ee/core/clients).
+ *
+ * Phase 1: Core CRUD + hooks + validation
+ * Phase 2 (TODO): Access control, request context, scoping
+ *
+ * @typeParam AllFields - The entity's complete field map. Inferred automatically
+ *                        when constructing via `createAdminClient(entity)`.
+ */
+declare class AdminClient<AllFields extends Record<string, FieldConfig> = Record<string, FieldConfig>> {
+    private entity;
+    private db;
+    private logger?;
+    private createSchema;
+    private updateSchema;
+    private table;
+    private countCache?;
+    constructor(config: AdminClientConfig<AllFields>);
+    /**
+     * Create a new entity
+     *
+     * Flow:
+     * 1. Validate input with Zod
+     * 2. Execute beforeCreate hooks
+     * 3. Prepare data for insert
+     * 4. Insert into database
+     * 5. Execute afterCreate hooks
+     * 6. Shape DTO and return
+     */
+    create(data: InferCreateInput<AllFields>): Promise<InferEntityDTO<AllFields>>;
+    /**
+     * Find entity by ID
+     */
+    findById(id: string, options?: {
+        locale?: string;
+        defaultLocale?: string;
+    }): Promise<InferEntityDTO<AllFields> | null>;
+    /**
+     * Find multiple entities
+     */
+    findMany(options?: FindManyOptions): Promise<InferEntityDTO<AllFields>[]>;
+    /**
+     * Count entities matching optional conditions
+     */
+    count(options?: CountOptions): Promise<number>;
+    /**
+     * Update entity by ID
+     *
+     * Flow:
+     * 1. Validate input with Zod
+     * 2. Execute beforeUpdate hooks
+     * 3. Prepare data for update
+     * 4. Update in database
+     * 5. Execute afterUpdate hooks
+     * 6. Shape DTO and return
+     */
+    update(id: string, data: InferUpdateInput<AllFields>, options?: {
+        locale?: string;
+    }): Promise<InferEntityDTO<AllFields>>;
+    /**
+     * Delete entity by ID.
+     *
+     * Checks entity_refs for incoming references first — throws
+     * ReferencedEntityError if this entity is still used somewhere.
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * Prepare data for insert — every field is a real column.
+     */
+    private prepareDataForInsert;
+    /**
+     * Prepare data for update — every field is a real column.
+     * Standard column SET, no JSONB merge needed.
+     */
+    private prepareDataForUpdate;
+    /**
+     * Merge translations into entities for the specified locale.
+     * Reads translatable field values from real columns on the translation row.
+     */
+    private mergeTranslations;
+    /**
+     * Save translation for an entity.
+     * Each translatable field is a real column on the translation table.
+     */
+    saveTranslation(entityId: string, locale: string, translations: Record<string, unknown>): Promise<void>;
+    /**
+     * PHASE 3: Delete translation(s) for an entity
+     * If locale is provided, deletes specific locale; otherwise deletes all translations
+     */
+    deleteTranslation(entityId: string, locale?: string): Promise<void>;
+    /**
+     * Save block-level translations for an entity.
+     * For each block in each blocks field, extracts translatable field values
+     * and upserts them into {entity}_layout_translations.
+     *
+     * Block _id must match an existing layout row ID.
+     */
+    saveBlockTranslations(entityId: string, locale: string, data: Record<string, unknown>): Promise<void>;
+    /**
+     * Save per-locale blocks for an entity.
+     * Used for entities with `localized: true` on their blocks field — each locale gets
+     * its own independent block layout rows in the layout table.
+     */
+    saveLocalizedBlocks(entityId: string, locale: string, data: Record<string, unknown>): Promise<void>;
+    /**
+     * Get all blocks field names for this entity.
+     */
+    private getBlocksFields;
+    /**
+     * Save blocks for an entity after create/update.
+     * For each blocks field, writes rows to {entity}_layout table.
+     */
+    private saveBlocks;
+    /**
+     * Load blocks for one or more entities from the layout table.
+     *
+     * Handles both block translation modes:
+     * - Shared layout (localized: false): loads locale=NULL rows, merges translations,
+     *   clears untranslated translatable fields to '' (strict mode for admin editing)
+     * - Per-locale layout (localized: true): loads rows matching the provided locale only
+     *
+     * @param entityIds - Entity IDs to load blocks for
+     * @param locale - Content locale (omit for default locale / base data)
+     * @param options.defaultLocale - Default locale; NULL rows fall back only for this locale
+     */
+    private loadBlocks;
+    /**
+     * Attach loaded blocks to shaped DTOs.
+     */
+    private attachBlocks;
+    /**
+     * Sync outgoing references in entity_refs after create/update.
+     *
+     * - 'create': inserts all refs (entity is new, no existing refs)
+     * - 'update': deletes refs for changed ref-bearing fields, then inserts new ones
+     *
+     * Gracefully skips if entity_refs table is not registered (e.g. before migration).
+     */
+    private syncRefs;
+    /**
+     * Build a cache key for a count query.
+     * Key format: `entityName` for unfiltered, `entityName:where_sql` for filtered.
+     */
+    private buildCountCacheKey;
+    /**
+     * Invalidate all count cache entries for this entity.
+     */
+    private invalidateCountCache;
+}
+
+export { AdminClient, type AdminClientConfig, type CountCacheLike, type CountOptions, type FindManyOptions };

package/dist/admin/index.js

@@ -0,0 +1 @@
+import{schemaRegistry as R}from"@murumets-ee/db";import{and as C,eq as m,inArray as E,isNull as D,or as Y,sql as ee}from"drizzle-orm";import{and as Q,gt as q,lt as J,or as W,eq as K}from"drizzle-orm";function B(o,e){let t=o[e.field];if(!t)return null;let i=e.direction==="desc"?J:q,n=i(t,e.value);if(!e.id)return n;let r=o.id;if(!r)return n;let c=i(r,e.id);return W(n,Q(K(t,e.value),c))}function v(o,e,t){if(!e)return null;let s={},i=t?.select||Object.keys(o.allFields);for(let n of i){if(!t?.includeInternal&&n.startsWith("_"))continue;let r=o.allFields[n];r&&r.type!=="blocks"&&(s[n]=e[n])}return s}function _(o,e,t){return e.map(s=>v(o,s,t))}var A=class extends Error{entityName;entityId;usages;constructor(e,t,s){let i=s.length;super(`Cannot delete ${e} '${t}': referenced by ${i} other entit${i===1?"y":"ies"}`),this.name="ReferencedEntityError",this.entityName=e,this.entityId=t,this.usages=s}};var V=/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;function N(o,e){let t=[],s=new Set;function i(n,r,c){if(!V.test(c))return;let a=`${n}|${r}|${c}`;s.has(a)||(s.add(a),t.push({sourceField:n,targetEntity:r,targetId:c}))}for(let[n,r]of Object.entries(o)){let c=e[n];if(c!=null)switch(r.type){case"media":{typeof c=="string"&&i(n,"media",c);break}case"reference":{let a=r;if(a.cardinality==="many"&&Array.isArray(c))for(let l of c)typeof l=="string"&&i(n,a.entity,l);else typeof c=="string"&&i(n,a.entity,c);break}case"blocks":{let a=r;if(!Array.isArray(c))break;for(let l of c){let g=l,p=g._block;if(!p)continue;let d=a.blocks.find(f=>f.slug===p);if(d)for(let[f,y]of Object.entries(d.fields)){let u=g[f];if(u!=null&&(y.type==="media"&&typeof u=="string"&&i(n,"media",u),y.type==="reference")){let w=y;if(w.cardinality==="many"&&Array.isArray(u))for(let b of u)typeof b=="string"&&i(n,w.entity,b);else typeof u=="string"&&i(n,w.entity,u)}}}break}}}return t}import{and as X,eq as $}from"drizzle-orm";import{index as z,pgTable as G,unique as H,uuid as S,varchar as O}from"drizzle-orm/pg-core";var k=G("entity_refs",{sourceEntity:O("source_entity",{length:100}).notNull(),sourceId:S("source_id").notNull(),sourceField:O("source_field",{length:100}).notNull(),targetEntity:O("target_entity",{length:100}).notNull(),targetId:S("target_id").notNull()},o=>[H("uq_entity_refs").on(o.sourceEntity,o.sourceId,o.sourceField,o.targetEntity,o.targetId),z("idx_entity_refs_target").on(o.targetEntity,o.targetId),z("idx_entity_refs_source").on(o.sourceEntity,o.sourceId)]);async function L(o,e,t){return await t.select({sourceEntity:k.sourceEntity,sourceId:k.sourceId,sourceField:k.sourceField}).from(k).where(X($(k.targetEntity,o),$(k.targetId,e)))}import{z as h}from"zod";function U(o){let e;switch(o.type){case"id":e=h.string().uuid();break;case"text":e=h.string(),o.maxLength&&(e=e.max(o.maxLength)),o.minLength&&(e=e.min(o.minLength)),o.pattern&&(e=e.regex(o.pattern));break;case"number":e=h.number(),o.integer&&(e=e.int()),o.min!==void 0&&(e=e.min(o.min)),o.max!==void 0&&(e=e.max(o.max));break;case"boolean":e=h.boolean();break;case"date":e=h.date().or(h.string().datetime());break;case"select":e=h.enum(o.options);break;case"reference":o.cardinality==="many"?e=h.array(h.string().uuid()):e=h.string().uuid();break;case"media":e=h.string().uuid();break;case"richtext":e=h.union([h.string(),h.array(h.record(h.unknown()))]);break;case"slug":e=h.string().regex(/^[a-z0-9-]+$/);break;case"json":e=h.record(h.unknown());break;case"blocks":e=h.array(h.object({_block:h.string()}).passthrough());break;default:e=h.unknown()}return o.required||(e=e.nullable().optional()),o.default!==void 0&&(e=e.default(o.default)),e}function P(o){let e={},t=new Set(["id","createdAt","updatedAt","createdBy","_version"]);for(let[s,i]of Object.entries(o.allFields))t.has(s)||(e[s]=U(i));return h.object(e)}function M(o){let e={},t=new Set(["id","createdAt","createdBy","updatedAt","updatedBy","_version"]);for(let[s,i]of Object.entries(o.allFields))if(!t.has(s)){let n=U(i);e[s]=n.optional()}return h.object(e)}var x=class{entity;db;logger;createSchema;updateSchema;table;countCache;constructor(e){if(typeof window<"u")throw new Error("AdminClient cannot be used in browser code. Use QueryClient for frontend data access.");this.entity=e.entity,this.db=e.db,this.logger=e.logger,this.countCache=e.countCache,this.createSchema=P(e.entity),this.updateSchema=M(e.entity);let t=R.get(e.entity.name);if(!t)throw new Error(`Schema for entity '${e.entity.name}' not found in registry. Ensure schemas are generated and registered before creating AdminClient.`);this.table=t}async create(e){this.logger?.info({entity:this.entity.name},"Creating entity");let t=e;if(this.entity.hooks?.beforeCreate){let r=await this.entity.hooks.beforeCreate(t);t=r!==void 0?r:t}t=this.createSchema.parse(t);let s=this.prepareDataForInsert(t),[i]=await this.db.insert(this.table).values(s).returning();await this.saveBlocks(i.id,t),await this.syncRefs(i.id,t,"create"),this.entity.hooks?.afterCreate&&await this.entity.hooks.afterCreate(i),this.invalidateCountCache();let n=v(this.entity,i);if(n&&this.getBlocksFields().length>0){let r=await this.loadBlocks([n.id]);this.attachBlocks([n],r)}return n}async findById(e,t){this.logger?.info({entity:this.entity.name,id:e},"Finding entity by ID");let[s]=await this.db.select().from(this.table).where(m(this.table.id,e));if(!s)return null;let i=v(this.entity,s);if(!i)return null;if(this.getBlocksFields().length>0){let n=await this.loadBlocks([i.id],t?.locale,{defaultLocale:t?.defaultLocale});this.attachBlocks([i],n)}if(t?.locale){let[n]=await this.mergeTranslations([i],t.locale);return n}return i}async findMany(e){this.logger?.info({entity:this.entity.name,options:e},"Finding entities");let t=this.db.select().from(this.table).$dynamic(),s=[];if(e?.where&&s.push(e.where),e?.cursor){let r=this.entity.allFields;if(!(e.cursor.field in r)&&e.cursor.field!=="id")throw new Error(`Invalid cursor field: '${e.cursor.field}' is not a field on '${this.entity.name}'`);let c=B(this.table,e.cursor);c&&s.push(c)}if(s.length>0&&(t=t.where(C(...s))),e?.limit&&(t=t.limit(e.limit)),e?.offset&&!e?.cursor&&(t=t.offset(e.offset)),e?.orderBy){let r=Array.isArray(e.orderBy)?e.orderBy:[e.orderBy];t=t.orderBy(...r)}let i=await t,n=_(this.entity,i).filter(r=>r!==null);if(this.getBlocksFields().length>0&&n.length>0){let r=n.map(a=>a.id),c=await this.loadBlocks(r,e?.locale,{defaultLocale:e?.defaultLocale});this.attachBlocks(n,c)}return e?.locale?await this.mergeTranslations(n,e.locale):n}async count(e){this.logger?.info({entity:this.entity.name,options:e},"Counting entities");let t=this.buildCountCacheKey(e?.where);if(this.countCache){let r=this.countCache.get(t);if(r!==void 0)return this.logger?.debug?.({entity:this.entity.name,cached:r},"Count cache hit"),r}let s=this.db.select({count:ee`count(*)`}).from(this.table).$dynamic();e?.where&&(s=s.where(e.where));let[i]=await s,n=Number(i.count);return this.countCache&&this.countCache.set(t,n),n}async update(e,t,s){this.logger?.info({entity:this.entity.name,id:e},"Updating entity");let i=t;if(this.entity.hooks?.beforeUpdate){let a=await this.entity.hooks.beforeUpdate(e,i);i=a!==void 0?a:i}i=this.updateSchema.parse(i);let n=this.prepareDataForUpdate(i),r;if(Object.keys(n).length>0){let[a]=await this.db.update(this.table).set(n).where(m(this.table.id,e)).returning();r=a}else{let[a]=await this.db.select().from(this.table).where(m(this.table.id,e));r=a}await this.saveBlocks(e,i,s),await this.syncRefs(e,i,"update"),this.entity.hooks?.afterUpdate&&await this.entity.hooks.afterUpdate(r);let c=v(this.entity,r);if(c&&this.getBlocksFields().length>0){let a=await this.loadBlocks([e]);this.attachBlocks([c],a)}return c}async delete(e){this.logger?.info({entity:this.entity.name,id:e},"Deleting entity");let t=await L(this.entity.name,e,this.db);if(t.length>0)throw new A(this.entity.name,e,t);this.entity.hooks?.beforeDelete&&await this.entity.hooks.beforeDelete(e),await this.db.delete(this.table).where(m(this.table.id,e)),await this.db.delete(k).where(C(m(k.sourceEntity,this.entity.name),m(k.sourceId,e))),this.entity.hooks?.afterDelete&&await this.entity.hooks.afterDelete(e),this.invalidateCountCache()}prepareDataForInsert(e){let t={};for(let[s,i]of Object.entries(e)){let n=this.entity.allFields[s];n&&s!=="id"&&n.type!=="blocks"&&(t[s]=i)}return t}prepareDataForUpdate(e){let t={};for(let[s,i]of Object.entries(e)){let n=this.entity.allFields[s];n&&s!=="id"&&n.type!=="blocks"&&(t[s]=i)}return t}async mergeTranslations(e,t){if(!e.length)return e;let s=`${this.entity.name}_translations`,i=R.get(s);if(!i)return e;let n=e.map(l=>l.id),r=await this.db.select().from(i).where(C(E(i.entityId,n),m(i.locale,t))),c=Object.entries(this.entity.allFields).filter(([l,g])=>g.translatable).map(([l])=>l),a=new Map;for(let l of r){let g={};for(let p of c){let d=l[p];d!=null&&(g[p]=d)}a.set(l.entityId,g)}return e.map(l=>{let g=a.get(l.id);return g?{...l,...g}:l})}async saveTranslation(e,t,s){this.logger?.info({entity:this.entity.name,entityId:e,locale:t},"Saving translation");let i=`${this.entity.name}_translations`,n=R.get(i);if(!n)throw new Error(`Translation table ${i} not found in schema registry`);let r=Object.entries(this.entity.allFields).filter(([l,g])=>g.translatable).map(([l])=>l);if(r.length===0)throw new Error(`Entity ${this.entity.name} has no translatable fields`);let c={entityId:e,locale:t},a={};for(let l of r)s[l]!==void 0&&(c[l]=s[l],a[l]=s[l]);await this.db.insert(n).values(c).onConflictDoUpdate({target:[n.entityId,n.locale],set:a}),this.logger?.info({entity:this.entity.name,entityId:e,locale:t},"Translation saved")}async deleteTranslation(e,t){this.logger?.info({entity:this.entity.name,entityId:e,locale:t},"Deleting translation");let s=`${this.entity.name}_translations`,i=R.get(s);if(!i)throw new Error(`Translation table ${s} not found in schema registry`);t?(await this.db.delete(i).where(C(m(i.entityId,e),m(i.locale,t))),this.logger?.info({entity:this.entity.name,entityId:e,locale:t},"Translation deleted")):(await this.db.delete(i).where(m(i.entityId,e)),this.logger?.info({entity:this.entity.name,entityId:e},"All translations deleted"))}async saveBlockTranslations(e,t,s){this.logger?.info({entity:this.entity.name,entityId:e,locale:t},"Saving block translations");let i=this.getBlocksFields();if(i.length===0)return;let n=R.get(`${this.entity.name}_layout_translations`);if(!n)return;let r=R.get(`${this.entity.name}_layout`);if(r){for(let{name:c,config:a}of i){let l=s[c];if(!Array.isArray(l))continue;let g=a.blocks;if(!g)continue;let p=await this.db.select({id:r.id,blockType:r.blockType}).from(r).where(C(m(r.entityId,e),m(r.fieldName,c),D(r.locale))).orderBy(r.sortOrder);for(let d=0;d<l.length;d++){let f=l[d],y=f._block;if(!y)continue;let u=p[d];if(!u||u.blockType!==y)continue;let w=g.find(F=>F.slug===y);if(!w)continue;let b={};for(let[F,T]of Object.entries(w.fields))T.translatable&&f[F]!==void 0&&(b[F]=f[F]);Object.keys(b).length!==0&&await this.db.insert(n).values({layoutId:u.id,locale:t,fields:b}).onConflictDoUpdate({target:[n.layoutId,n.locale],set:{fields:b}})}}this.logger?.info({entity:this.entity.name,entityId:e,locale:t},"Block translations saved")}}async saveLocalizedBlocks(e,t,s){this.logger?.info({entity:this.entity.name,entityId:e,locale:t},"Saving localized blocks"),await this.saveBlocks(e,s,{locale:t})}getBlocksFields(){return Object.entries(this.entity.allFields).filter(([e,t])=>t.type==="blocks").map(([e,t])=>({name:e,config:t}))}async saveBlocks(e,t,s){let i=this.getBlocksFields();if(i.length===0)return;let n=R.get(`${this.entity.name}_layout`);if(n)for(let{name:r,config:c}of i){let a=t[r];if(!Array.isArray(a))continue;let l="localized"in c&&c.localized===!0,g=l?s?.locale??null:null,p=[m(n.entityId,e),m(n.fieldName,r)];g?p.push(m(n.locale,g)):l||p.push(D(n.locale)),await this.db.delete(n).where(C(...p));for(let d=0;d<a.length;d++){let f=a[d],y=f._block;if(!y)continue;let{_block:u,_id:w,...b}=f;await this.db.insert(n).values({entityId:e,fieldName:r,blockType:y,sortOrder:d,data:b,locale:g})}}}async loadBlocks(e,t,s){let i=this.getBlocksFields();if(i.length===0||e.length===0)return new Map;let n=R.get(`${this.entity.name}_layout`);if(!n)return new Map;let r=i.filter(({config:l})=>!("localized"in l&&l.localized)),c=i.filter(({config:l})=>"localized"in l&&l.localized),a=new Map;if(r.length>0){let l=await this.db.select().from(n).where(C(E(n.entityId,e),D(n.locale))).orderBy(n.sortOrder),g;if(t&&l.length>0){let d=R.get(`${this.entity.name}_layout_translations`);if(d){let f=l.map(u=>u.id),y=await this.db.select().from(d).where(C(E(d.layoutId,f),m(d.locale,t)));g=new Map;for(let u of y)g.set(u.layoutId,u.fields??{})}}let p=new Map;for(let{config:d}of r){let f=d.blocks;if(f)for(let y of f)p.set(y.slug,y.fields)}for(let d of l){let f=d.entityId,y=d.fieldName;a.has(f)||a.set(f,{});let u=a.get(f);u[y]||(u[y]=[]);let w=d.data??{},b=g?.get(d.id),F={_block:d.blockType,_id:d.id,...w,...b??{}};if(t){let T=d.blockType,I=p.get(T);if(I)for(let[j,Z]of Object.entries(I))Z.translatable&&!b?.[j]&&(F[j]="")}u[y].push(F)}}if(c.length>0){let l=!t||t===s?.defaultLocale,g=t?l?Y(m(n.locale,t),D(n.locale)):m(n.locale,t):D(n.locale),p=await this.db.select().from(n).where(C(E(n.entityId,e),g)).orderBy(n.sortOrder),d=new Map;for(let f of p){let y=`${f.entityId}::${f.fieldName}`;d.has(y)||d.set(y,{localeRows:[],nullRows:[]});let u=d.get(y);f.locale?u.localeRows.push(f):u.nullRows.push(f)}for(let[,{localeRows:f,nullRows:y}]of d){let u=f.length>0?f:y;for(let w of u){let b=w.entityId,F=w.fieldName;a.has(b)||a.set(b,{});let T=a.get(b);T[F]||(T[F]=[]);let I=w.data??{};T[F].push({_block:w.blockType,_id:w.id,...I})}}}return a}attachBlocks(e,t){let s=this.getBlocksFields();if(s.length!==0)for(let i of e){let n=i.id,r=t.get(n)??{};for(let{name:c}of s)i[c]=r[c]??[]}}async syncRefs(e,t,s){if(!R.has("entity_refs"))return;let i=this.entity.allFields;if(s==="update"){let r=Object.keys(t).filter(c=>{let a=i[c];return a&&(a.type==="media"||a.type==="reference"||a.type==="blocks")});r.length>0&&await this.db.delete(k).where(C(m(k.sourceEntity,this.entity.name),m(k.sourceId,e),E(k.sourceField,r)))}let n=N(i,t);n.length>0&&await this.db.insert(k).values(n.map(r=>({sourceEntity:this.entity.name,sourceId:e,sourceField:r.sourceField,targetEntity:r.targetEntity,targetId:r.targetId}))).onConflictDoNothing()}buildCountCacheKey(e){return e?`${this.entity.name}:${String(e)}`:this.entity.name}invalidateCountCache(){this.countCache?.invalidate(this.entity.name)}};export{x as AdminClient};