kernelcms 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,224 @@
+import { T as SanitizedConfig, E as KernelConfig, K as Kernel, m as CollectionConfig, G as GlobalConfig, b as AccessResult, a as AccessFn, A as AccessArgs, c as AnyField, W as SelectOption, Q as RequestContext, r as Doc, p as CreateOptions, y as FindOptions, w as FindByIDOptions, Z as UpdateOptions, q as DeleteOptions, o as CountOptions, I as LoginOptions, f as AuthResult, g as AuthUser, x as FindGlobalOptions, Y as UpdateGlobalOptions, u as FieldType, s as FieldAdmin } from './types-DMOX4FIP.js';
+export { d as ArrayField, e as AuthOptions, B as BooleanField, C as CollectionAccess, h as CollectionAfterChangeHook, i as CollectionAfterDeleteHook, j as CollectionAfterReadHook, k as CollectionBeforeChangeHook, l as CollectionBeforeDeleteHook, n as CollectionHooks, D as DateField, F as FieldAccess, t as FieldBase, v as FieldValidateArgs, z as GroupField, H as HookArgs, J as JSONField, L as LocalizationConfig, N as NumberField, O as Operation, M as OperationBase, P as PointField, R as RelationshipField, S as RichTextField, U as SanitizedLocalization, V as SelectField, X as TextField, _ as ValidateFn } from './types-DMOX4FIP.js';
+import { L as Logger, K as KernelSchema, R as Row, W as Where, S as SortSpec, C as ColumnSchema, d as StorageType, D as DatabaseAdapter, P as PaginatedResult } from './index-BxvPeUO2.js';
+export { A as Adapter, a as AdapterContext, b as DatabaseAdapterFactory, c as DatabaseCapabilities, M as MigrationReport, T as TableSchema, e as WhereCondition, f as WhereOperator } from './index-BxvPeUO2.js';
+
+/** Identity helper that gives `kernel.config.ts` full type-checking and inference. */
+declare function defineConfig(config: KernelConfig): KernelConfig;
+declare function sanitizeConfig(config: KernelConfig): SanitizedConfig;
+declare function defaultLocaleOf(config: SanitizedConfig): string;
+
+declare const LEVELS: {
+    readonly debug: 10;
+    readonly info: 20;
+    readonly warn: 30;
+    readonly error: 40;
+};
+declare function createLogger(level?: keyof typeof LEVELS): Logger;
+interface InitOptions {
+    /** Apply the schema (create/alter tables) during init. Default false. */
+    autoMigrate?: boolean;
+    logLevel?: keyof typeof LEVELS;
+}
+/** Boot a Kernel instance: sanitize config, init the adapter, expose the Local API. */
+declare function initKernel(config: KernelConfig, options?: InitOptions): Promise<Kernel>;
+
+declare function tableForCollection(slug: string): string;
+declare function tableForGlobal(slug: string): string;
+/** The fixed primary-key id used for the single row backing a global. */
+declare const GLOBAL_ROW_ID = "singleton";
+/** Compile the sanitized config into the storage-facing schema for the adapter. */
+declare function compileSchema(config: SanitizedConfig): KernelSchema;
+
+interface CodegenInput {
+    collections: CollectionConfig[];
+    globals: GlobalConfig[];
+}
+/** Generate a TypeScript declaration string describing every collection and global. */
+declare function generateTypes(input: CodegenInput): string;
+
+/** Parse Payload-style sort strings ("-createdAt,title") into a SortSpec list. */
+declare function parseSort(sort: string | string[] | undefined): SortSpec[];
+declare function mergeWhere(a: Where | undefined, b: Where | undefined): Where | undefined;
+/** In-memory evaluation of a Where clause against a row (used for access guards/population). */
+declare function matchesWhere(row: Row, where: Where | undefined): boolean;
+
+/**
+ * Evaluate an access rule. When no rule is defined, KernelCMS is secure by
+ * default: the operation is allowed only for authenticated users. Collections
+ * that should be publicly readable must opt in with `access.read: () => true`.
+ */
+declare function evalAccess(fn: AccessFn | undefined, args: AccessArgs): Promise<AccessResult>;
+/** A result is "allowed" unless it is explicitly `false`. A `Where` means allowed-but-scoped. */
+declare function isAllowed(result: AccessResult): boolean;
+declare function asWhere(result: AccessResult): Where | undefined;
+
+/** Typed error hierarchy. Every failure crossing an API boundary is a KernelError. */
+type ErrorCode = 'VALIDATION' | 'NOT_FOUND' | 'FORBIDDEN' | 'UNAUTHORIZED' | 'CONFLICT' | 'BAD_REQUEST' | 'TOO_MANY_REQUESTS' | 'INTERNAL';
+interface FieldError {
+    path: string;
+    message: string;
+}
+declare class KernelError extends Error {
+    readonly code: ErrorCode;
+    readonly status: number;
+    readonly details: unknown;
+    constructor(message: string, code: ErrorCode, status: number, details?: unknown);
+    toJSON(): {
+        error: {
+            code: ErrorCode;
+            message: string;
+            details?: unknown;
+        };
+    };
+}
+declare class ValidationError extends KernelError {
+    readonly errors: FieldError[];
+    constructor(errors: FieldError[]);
+}
+declare class NotFoundError extends KernelError {
+    constructor(message?: string);
+}
+declare class ForbiddenError extends KernelError {
+    constructor(message?: string);
+}
+declare class UnauthorizedError extends KernelError {
+    constructor(message?: string);
+}
+declare class BadRequestError extends KernelError {
+    constructor(message?: string, details?: unknown);
+}
+declare class ConflictError extends KernelError {
+    constructor(message?: string, details?: unknown);
+}
+declare class TooManyRequestsError extends KernelError {
+    /** Seconds the client should wait before retrying, surfaced as Retry-After. */
+    readonly retryAfter?: number;
+    constructor(message?: string, retryAfter?: number);
+}
+declare function isKernelError(err: unknown): err is KernelError;
+
+declare function humanize(name: string): string;
+declare function fieldLabel(field: AnyField): string;
+declare function optionValue(opt: SelectOption): string;
+declare function optionLabel(opt: SelectOption): string;
+/** The physical storage type for a field, accounting for localization and arity. */
+declare function storageTypeForField(field: AnyField): StorageType;
+declare function columnForField(field: AnyField): ColumnSchema;
+/** Resolve a field's default value (supports literal or factory). */
+declare function defaultForField(field: AnyField): unknown;
+declare function applyDefaults(fields: AnyField[], data: Row): Row;
+interface ValidateContext {
+    req: RequestContext;
+    operation: 'create' | 'update';
+}
+declare function validateFields(fields: AnyField[], data: Row, ctx: ValidateContext, prefix?: string): Promise<FieldError[]>;
+interface SerializeOptions {
+    locale: string;
+    existingRow?: Row | null;
+}
+/** Build a storage row from public field data, merging localized values. */
+declare function serializeDoc(fields: AnyField[], data: Row, opts: SerializeOptions): Row;
+interface DeserializeOptions {
+    locale: string;
+    fallbackLocale: string | false;
+}
+/** Resolve a storage row into a public document body (localized values resolved). */
+declare function deserializeDoc(fields: AnyField[], row: Row, opts: DeserializeOptions): Row;
+/** Top-level relationship fields that can be populated. */
+declare function relationshipFields(fields: AnyField[]): Array<{
+    name: string;
+    relationTo: string;
+    hasMany: boolean;
+}>;
+
+interface OperationCtx {
+    config: SanitizedConfig;
+    db: DatabaseAdapter;
+}
+declare function createOperations(ctx: OperationCtx): {
+    create: <T extends Doc = Doc>(opts: CreateOptions) => Promise<T>;
+    find: <T extends Doc = Doc>(opts: FindOptions) => Promise<PaginatedResult<T>>;
+    findByID: <T extends Doc = Doc>(opts: FindByIDOptions) => Promise<T | null>;
+    update: <T extends Doc = Doc>(opts: UpdateOptions) => Promise<T | null>;
+    delete: <T extends Doc = Doc>(opts: DeleteOptions) => Promise<T | null>;
+    count: (opts: CountOptions) => Promise<number>;
+    login: (opts: LoginOptions) => Promise<AuthResult>;
+    authenticate: (token: string) => Promise<AuthUser | null>;
+    findGlobal: <T extends Row = Row>(opts: FindGlobalOptions) => Promise<T>;
+    updateGlobal: <T extends Row = Row>(opts: UpdateGlobalOptions) => Promise<T>;
+};
+type Operations = ReturnType<typeof createOperations>;
+
+declare function hashPassword(password: string): Promise<string>;
+declare function verifyPassword(password: string, stored: string): Promise<boolean>;
+interface TokenPayload {
+    sub: string;
+    collection: string;
+    iat?: number;
+    exp?: number;
+    [key: string]: unknown;
+}
+declare function signToken(payload: Omit<TokenPayload, 'iat' | 'exp'>, secret: string, expiresInSec?: number): string;
+declare function verifyToken(token: string, secret: string): TokenPayload | null;
+
+/**
+ * Produce a serializable description of the content model for the admin UI and
+ * external tooling. Access functions, validators, and hooks are intentionally
+ * omitted — only data needed to render forms and tables is included.
+ */
+
+interface AdminFieldOption {
+    label: string;
+    value: string;
+}
+interface AdminField {
+    name: string;
+    type: FieldType | 'password';
+    label: string;
+    required: boolean;
+    unique: boolean;
+    localized: boolean;
+    hasMany?: boolean;
+    relationTo?: string;
+    options?: AdminFieldOption[];
+    fields?: AdminField[];
+    min?: number;
+    max?: number;
+    minLength?: number;
+    maxLength?: number;
+    admin?: Omit<FieldAdmin, 'condition'>;
+}
+interface AdminCollection {
+    slug: string;
+    labels: {
+        singular: string;
+        plural: string;
+    };
+    useAsTitle: string;
+    defaultColumns?: string[];
+    group?: string;
+    description?: string;
+    auth: boolean;
+    hidden: boolean;
+    fields: AdminField[];
+}
+interface AdminGlobal {
+    slug: string;
+    label: string;
+    fields: AdminField[];
+}
+interface AdminSchema {
+    collections: AdminCollection[];
+    globals: AdminGlobal[];
+    localization: {
+        locales: string[];
+        defaultLocale: string;
+    } | null;
+    routes: {
+        api: string;
+    };
+}
+declare function describeConfig(config: SanitizedConfig): AdminSchema;
+
+export { AccessArgs, AccessFn, AccessResult, type AdminCollection, type AdminField, type AdminFieldOption, type AdminGlobal, type AdminSchema, AnyField, AuthResult, AuthUser, BadRequestError, type CodegenInput, CollectionConfig, ColumnSchema, ConflictError, CountOptions, CreateOptions, DatabaseAdapter, DeleteOptions, Doc, type ErrorCode, FieldAdmin, type FieldError, FieldType, FindByIDOptions, FindGlobalOptions, FindOptions, ForbiddenError, GLOBAL_ROW_ID, GlobalConfig, type InitOptions, Kernel, KernelConfig, KernelError, KernelSchema, Logger, LoginOptions, NotFoundError, type OperationCtx, type Operations, PaginatedResult, RequestContext, Row, SanitizedConfig, SelectOption, SortSpec, StorageType, type TokenPayload, TooManyRequestsError, UnauthorizedError, UpdateGlobalOptions, UpdateOptions, ValidationError, Where, applyDefaults, asWhere, columnForField, compileSchema, createLogger, createOperations, defaultForField, defaultLocaleOf, defineConfig, describeConfig, deserializeDoc, evalAccess, fieldLabel, generateTypes, hashPassword, humanize, initKernel, isAllowed, isKernelError, matchesWhere, mergeWhere, optionLabel, optionValue, parseSort, relationshipFields, sanitizeConfig, serializeDoc, signToken, storageTypeForField, tableForCollection, tableForGlobal, validateFields, verifyPassword, verifyToken };

package/dist/index.js

@@ -0,0 +1,90 @@
+import {
+  BadRequestError,
+  ConflictError,
+  ForbiddenError,
+  GLOBAL_ROW_ID,
+  KernelError,
+  NotFoundError,
+  TooManyRequestsError,
+  UnauthorizedError,
+  ValidationError,
+  applyDefaults,
+  asWhere,
+  columnForField,
+  compileSchema,
+  createLogger,
+  createOperations,
+  defaultForField,
+  defaultLocaleOf,
+  defineConfig,
+  describeConfig,
+  deserializeDoc,
+  evalAccess,
+  fieldLabel,
+  generateTypes,
+  hashPassword,
+  humanize,
+  initKernel,
+  isAllowed,
+  isKernelError,
+  matchesWhere,
+  mergeWhere,
+  optionLabel,
+  optionValue,
+  parseSort,
+  relationshipFields,
+  sanitizeConfig,
+  serializeDoc,
+  signToken,
+  storageTypeForField,
+  tableForCollection,
+  tableForGlobal,
+  validateFields,
+  verifyPassword,
+  verifyToken
+} from "./chunk-O5TO5JFA.js";
+export {
+  BadRequestError,
+  ConflictError,
+  ForbiddenError,
+  GLOBAL_ROW_ID,
+  KernelError,
+  NotFoundError,
+  TooManyRequestsError,
+  UnauthorizedError,
+  ValidationError,
+  applyDefaults,
+  asWhere,
+  columnForField,
+  compileSchema,
+  createLogger,
+  createOperations,
+  defaultForField,
+  defaultLocaleOf,
+  defineConfig,
+  describeConfig,
+  deserializeDoc,
+  evalAccess,
+  fieldLabel,
+  generateTypes,
+  hashPassword,
+  humanize,
+  initKernel,
+  isAllowed,
+  isKernelError,
+  matchesWhere,
+  mergeWhere,
+  optionLabel,
+  optionValue,
+  parseSort,
+  relationshipFields,
+  sanitizeConfig,
+  serializeDoc,
+  signToken,
+  storageTypeForField,
+  tableForCollection,
+  tableForGlobal,
+  validateFields,
+  verifyPassword,
+  verifyToken
+};

package/dist/postgres.d.ts

@@ -0,0 +1,21 @@
+import { PoolConfig } from 'pg';
+import { D as DatabaseAdapter } from './index-BxvPeUO2.js';
+
+interface PostgresAdapterOptions {
+    /** Connection string. Defaults to `process.env.DATABASE_URL`. */
+    url?: string;
+    /**
+     * TLS. `true` is a convenience for hosted Postgres that presents a cert the
+     * system store doesn't verify (`{ rejectUnauthorized: false }`); pass a full
+     * object for stricter setups.
+     */
+    ssl?: boolean | PoolConfig['ssl'];
+    /** Maximum pooled clients. Default 10. */
+    max?: number;
+    /** Escape hatch: a full pg PoolConfig, merged last. */
+    pool?: PoolConfig;
+}
+/** Create a PostgreSQL database adapter. */
+declare function postgresAdapter(options?: PostgresAdapterOptions): DatabaseAdapter;
+
+export { type PostgresAdapterOptions, postgresAdapter };