@kitledger/core 0.0.7 → 0.0.9

package/dist/fields.d.ts

@@ -1,3 +1,6 @@
+/**
+ * Enumeration of supported field types.
+ */
 export declare enum FieldType {
     TEXT = "text",
     NUMBER = "number",
@@ -7,17 +10,27 @@ export declare enum FieldType {
     SELECT = "select",
     RELATION = "relation"
 }
+/**
+ * Base interface for all field definitions.
+ */
 interface BaseField {
-    readonly ref_id: string;
+    readonly refId: string;
     name: string;
     description?: string;
+    required: boolean;
 }
+/**
+ * Type definition for a text field.
+ */
 export interface TextField extends BaseField {
     type: FieldType.TEXT;
-    readonly __primitive_type?: string;
+    readonly __valueType: string;
     maxLength?: number;
     format?: "email" | "plain" | "rich_text";
 }
+/**
+ * Type definition for a number field.
+ */
 export type NumberFormatting = {
     style: "integer";
 } | {
@@ -27,33 +40,51 @@ export type NumberFormatting = {
     style: "currency";
     currencyCode: string;
 };
+/**
+ * Type definition for a number field.
+ */
 export interface NumberField extends BaseField {
     type: FieldType.NUMBER;
-    readonly __primitive_type?: number;
+    readonly __valueType: number;
     min?: number;
     max?: number;
     formatting: NumberFormatting;
 }
+/**
+ * Type definition for a date field.
+ */
 export interface DateField extends BaseField {
     type: FieldType.DATE;
-    readonly __primitive_type?: Date;
+    readonly __valueType: Date;
     includeTime: boolean;
     formatStr: string;
 }
+/**
+ * Type definition for a boolean field.
+ */
 export interface BooleanField extends BaseField {
     type: FieldType.BOOLEAN;
-    readonly __primitive_type?: boolean;
+    readonly __valueType: boolean;
     defaultValue?: boolean;
 }
+/**
+ * Type definition for a URL field.
+ */
 export interface URLField extends BaseField {
     type: FieldType.URL;
-    readonly __primitive_type?: string;
+    readonly __valueType: string;
     defaultValue?: string;
 }
+/**
+ * TEMPORARY: Type definition for query configuration in relation fields.
+ */
 export type QueryConfig = {};
+/**
+ * Type definition for a select field.
+ */
 export interface SelectField extends BaseField {
     type: FieldType.SELECT;
-    readonly __primitive_type?: string | number | (string | number)[];
+    readonly __valueType: string | number | (string | number)[];
     multiSelect: boolean;
     items: Array<{
         label: string;
@@ -62,55 +93,169 @@ export interface SelectField extends BaseField {
     }>;
     defaultValue?: string | number | Array<string | number>;
 }
+/**
+ * Type definition for a relation field.
+ */
 export interface RelationField extends BaseField {
     type: FieldType.RELATION;
-    readonly __primitive_type?: any;
+    readonly __valueType: any;
     multiSelect: boolean;
     targetEntityId: string;
     displayFieldId: string;
     query: QueryConfig;
 }
+/**
+ * Union type for all field definitions.
+ */
 export type Field = TextField | NumberField | DateField | BooleanField | URLField | SelectField | RelationField;
-export type TextFieldOptions = Omit<TextField, "type" | "__primitive_type" | "ref_id">;
-export type NumberFieldOptions = Omit<NumberField, "type" | "__primitive_type" | "ref_id">;
-export type DateFieldOptions = Omit<DateField, "type" | "__primitive_type" | "ref_id">;
-export type BooleanFieldOptions = Omit<BooleanField, "type" | "__primitive_type" | "ref_id">;
-export type URLFieldOptions = Omit<URLField, "type" | "__primitive_type" | "ref_id">;
-export type SelectFieldOptions = Omit<SelectField, "type" | "__primitive_type" | "ref_id">;
-export type RelationFieldOptions = Omit<RelationField, "type" | "__primitive_type" | "ref_id">;
-export declare function defineTextField<const T extends string>(options: TextFieldOptions & {
-    ref_id: T;
+/**
+ * Options for defining a text field.
+ */
+export type TextFieldOptions = Omit<TextField, "type" | "__valueType" | "refId" | "required"> & {
+    required?: boolean;
+};
+/**
+ * Options for defining other field types.
+ */
+export type NumberFieldOptions = Omit<NumberField, "type" | "__valueType" | "refId" | "required"> & {
+    required?: boolean;
+};
+/**
+ * Options for defining other field types.
+ */
+export type DateFieldOptions = Omit<DateField, "type" | "__valueType" | "refId" | "required"> & {
+    required?: boolean;
+};
+/**
+ * Options for defining other field types.
+ */
+export type BooleanFieldOptions = Omit<BooleanField, "type" | "__valueType" | "refId" | "required"> & {
+    required?: boolean;
+};
+/**
+ * Options for defining other field types.
+ */
+export type URLFieldOptions = Omit<URLField, "type" | "__valueType" | "refId" | "required"> & {
+    required?: boolean;
+};
+/**
+ * Options for defining other field types.
+ */
+export type SelectFieldOptions = Omit<SelectField, "type" | "__valueType" | "refId" | "required"> & {
+    required?: boolean;
+};
+/**
+ * Options for defining other field types.
+ */
+export type RelationFieldOptions = Omit<RelationField, "type" | "__valueType" | "refId" | "required"> & {
+    required?: boolean;
+};
+/**
+ * Factory functions to define fields of various types.
+ *
+ * @remarks
+ * These functions help in creating strongly typed field definitions by inferring
+ *
+ * @param options - The options for defining the field.
+ * @returns The defined field with its type.
+ */
+export declare function defineTextField<const T extends string, const R extends boolean = false>(options: TextFieldOptions & {
+    refId: T;
+    required?: R;
 }): TextField & {
-    ref_id: T;
+    refId: T;
+    required: R;
 };
-export declare function defineNumberField<const T extends string>(options: NumberFieldOptions & {
-    ref_id: T;
+/**
+ * Factory function to define a number field.
+ *
+ * @remarks
+ * These functions help in creating strongly typed field definitions by inferring
+ *
+ * @param options - The options for defining the field.
+ * @returns The defined field with its type.
+ */
+export declare function defineNumberField<const T extends string, const R extends boolean = false>(options: NumberFieldOptions & {
+    refId: T;
+    required?: R;
 }): NumberField & {
-    ref_id: T;
+    refId: T;
+    required: R;
 };
-export declare function defineDateField<const T extends string>(options: DateFieldOptions & {
-    ref_id: T;
+/**
+ * Factory function to define a date field.
+ *
+ * @remarks
+ * These functions help in creating strongly typed field definitions by inferring
+ *
+ * @param options - The options for defining the field.
+ * @returns The defined field with its type.
+ */
+export declare function defineDateField<const T extends string, const R extends boolean = false>(options: DateFieldOptions & {
+    refId: T;
+    required?: R;
 }): DateField & {
-    ref_id: T;
+    refId: T;
+    required: R;
 };
-export declare function defineBooleanField<const T extends string>(options: BooleanFieldOptions & {
-    ref_id: T;
+/**
+ * Factory function to define a boolean field.
+ *
+ * @remarks
+ * These functions help in creating strongly typed field definitions by inferring
+ *
+ * @param options - The options for defining the field.
+ * @returns The defined field with its type.
+ */
+export declare function defineBooleanField<const T extends string, const R extends boolean = false>(options: BooleanFieldOptions & {
+    refId: T;
+    required?: R;
 }): BooleanField & {
-    ref_id: T;
+    refId: T;
+    required: R;
 };
-export declare function defineURLField<const T extends string>(options: URLFieldOptions & {
-    ref_id: T;
+/**
+ * Factory function to define a URL field.
+ * @param options - The options for defining the field.
+ * @returns The defined field with its type.
+ */
+export declare function defineURLField<const T extends string, const R extends boolean = false>(options: URLFieldOptions & {
+    refId: T;
+    required?: R;
 }): URLField & {
-    ref_id: T;
+    refId: T;
+    required: R;
 };
-export declare function defineSelectField<const T extends string>(options: SelectFieldOptions & {
-    ref_id: T;
+/**
+ * Factory function to define a select field.
+ *
+ * @remarks
+ * These functions help in creating strongly typed field definitions by inferring
+ *
+ * @param options - The options for defining the field.
+ * @returns The defined field with its type.
+ */
+export declare function defineSelectField<const T extends string, const R extends boolean = false>(options: SelectFieldOptions & {
+    refId: T;
+    required?: R;
 }): SelectField & {
-    ref_id: T;
+    refId: T;
+    required: R;
 };
-export declare function defineRelationField<const T extends string>(options: RelationFieldOptions & {
-    ref_id: T;
+/**
+ * Factory function to define a relation field.
+ *
+ * @remarks
+ * These functions help in creating strongly typed field definitions by inferring
+ *
+ * @param options - The options for defining the field.
+ * @returns The defined field with its type.
+ */
+export declare function defineRelationField<const T extends string, const R extends boolean = false>(options: RelationFieldOptions & {
+    refId: T;
+    required?: R;
 }): RelationField & {
-    ref_id: T;
+    refId: T;
+    required: R;
 };
 export {};

package/dist/fields.js

@@ -1,3 +1,6 @@
+/**
+ * Enumeration of supported field types.
+ */
 export var FieldType;
 (function (FieldType) {
     FieldType["TEXT"] = "text";
@@ -8,24 +11,118 @@ export var FieldType;
     FieldType["SELECT"] = "select";
     FieldType["RELATION"] = "relation";
 })(FieldType || (FieldType = {}));
+/**
+ * Factory functions to define fields of various types.
+ *
+ * @remarks
+ * These functions help in creating strongly typed field definitions by inferring
+ *
+ * @param options - The options for defining the field.
+ * @returns The defined field with its type.
+ */
 export function defineTextField(options) {
-    return { type: FieldType.TEXT, ...options };
+    const { required = false, ...rest } = options;
+    return {
+        type: FieldType.TEXT,
+        required,
+        ...rest,
+    };
 }
+/**
+ * Factory function to define a number field.
+ *
+ * @remarks
+ * These functions help in creating strongly typed field definitions by inferring
+ *
+ * @param options - The options for defining the field.
+ * @returns The defined field with its type.
+ */
 export function defineNumberField(options) {
-    return { type: FieldType.NUMBER, ...options };
+    const { required = false, ...rest } = options;
+    return {
+        type: FieldType.NUMBER,
+        required,
+        ...rest,
+    };
 }
+/**
+ * Factory function to define a date field.
+ *
+ * @remarks
+ * These functions help in creating strongly typed field definitions by inferring
+ *
+ * @param options - The options for defining the field.
+ * @returns The defined field with its type.
+ */
 export function defineDateField(options) {
-    return { type: FieldType.DATE, ...options };
+    const { required = false, ...rest } = options;
+    return {
+        type: FieldType.DATE,
+        required,
+        ...rest,
+    };
 }
+/**
+ * Factory function to define a boolean field.
+ *
+ * @remarks
+ * These functions help in creating strongly typed field definitions by inferring
+ *
+ * @param options - The options for defining the field.
+ * @returns The defined field with its type.
+ */
 export function defineBooleanField(options) {
-    return { type: FieldType.BOOLEAN, ...options };
+    const { required = false, ...rest } = options;
+    return {
+        type: FieldType.BOOLEAN,
+        required,
+        ...rest,
+    };
 }
+/**
+ * Factory function to define a URL field.
+ * @param options - The options for defining the field.
+ * @returns The defined field with its type.
+ */
 export function defineURLField(options) {
-    return { type: FieldType.URL, ...options };
+    const { required = false, ...rest } = options;
+    return {
+        type: FieldType.URL,
+        required,
+        ...rest,
+    };
 }
+/**
+ * Factory function to define a select field.
+ *
+ * @remarks
+ * These functions help in creating strongly typed field definitions by inferring
+ *
+ * @param options - The options for defining the field.
+ * @returns The defined field with its type.
+ */
 export function defineSelectField(options) {
-    return { type: FieldType.SELECT, ...options };
+    const { required = false, ...rest } = options;
+    return {
+        type: FieldType.SELECT,
+        required,
+        ...rest,
+    };
 }
+/**
+ * Factory function to define a relation field.
+ *
+ * @remarks
+ * These functions help in creating strongly typed field definitions by inferring
+ *
+ * @param options - The options for defining the field.
+ * @returns The defined field with its type.
+ */
 export function defineRelationField(options) {
-    return { type: FieldType.RELATION, ...options };
+    const { required = false, ...rest } = options;
+    return {
+        type: FieldType.RELATION,
+        required,
+        ...rest,
+    };
 }

package/dist/forms.d.ts

@@ -0,0 +1,130 @@
+import type { EntityModel } from "./entities.js";
+import type { Field } from "./fields.js";
+import type { TransactionModel } from "./transactions.js";
+import type { UnitModel } from "./units.js";
+/**
+ * The type of form being defined.
+ */
+export declare enum FormType {
+    ENTITY = "ENTITY",
+    TRANSACTION = "TRANSACTION",
+    UNIT = "UNIT"
+}
+/**
+ * How a form field is displayed.
+ */
+export type FormFieldDisplay = "normal" | "inline" | "disabled" | "hidden";
+/**
+ * Configuration options for a form field.
+ */
+export type FormFieldConfig = {
+    label?: string;
+    description?: string;
+    display?: FormFieldDisplay;
+};
+/**
+ * Infers the form field configuration from a list of fields.
+ */
+type InferFieldConfig<TFields extends readonly Field[]> = {
+    [K in TFields[number] as K["refId"]]?: FormFieldConfig & {
+        required?: K["required"] extends true ? true : boolean;
+    };
+};
+/**
+ * Base interface for all forms.
+ */
+export interface BaseForm {
+    refId: string;
+    modelRefId: string;
+    name: string;
+    description?: string;
+    fieldOrder?: string[];
+}
+/**
+ * Configuration options for entity forms
+ */
+export type EntityFormOptions<TModel extends {
+    fields?: readonly any[];
+}> = {
+    name: string;
+    description?: string;
+    refId: string;
+    fields: InferFieldConfig<NonNullable<TModel["fields"]>>;
+};
+/**
+ * Configuration options for unit forms
+ */
+export type UnitFormOptions<TModel extends {
+    fields?: readonly any[];
+}> = {
+    name: string;
+    description?: string;
+    refId: string;
+    fields: InferFieldConfig<NonNullable<TModel["fields"]>>;
+};
+/**
+ * Configuration options for transaction forms
+ */
+export type TransactionFormOptions<TModel extends {
+    fields?: readonly any[];
+}> = {
+    name: string;
+    description?: string;
+    refId: string;
+    fields: InferFieldConfig<NonNullable<TModel["fields"]>>;
+};
+/**
+ * Form definition for transactions.
+ */
+export interface TransactionForm<TModel extends TransactionModel> extends BaseForm {
+    type: FormType.TRANSACTION;
+    fields: InferFieldConfig<NonNullable<TModel["fields"]>>;
+}
+/**
+ * Form definition for entities.
+ */
+export interface EntityForm<TModel extends EntityModel> extends BaseForm {
+    type: FormType.ENTITY;
+    fields: InferFieldConfig<NonNullable<TModel["fields"]>>;
+}
+/**
+ * Form definition for units.
+ */
+export interface UnitForm<TModel extends UnitModel> extends BaseForm {
+    type: FormType.UNIT;
+    fields: InferFieldConfig<NonNullable<TModel["fields"]>>;
+}
+/**
+ * Factory function to define a transaction form.
+ *
+ * @remarks
+ * This is a pure configuration function that helps create a transaction form
+ *
+ * @param model The transaction model the form is based on
+ * @param config The configuration options for the form
+ * @returns A transaction form definition
+ */
+export declare function defineTransactionForm<const TModel extends TransactionModel>(model: TModel, config: TransactionFormOptions<TModel>): TransactionForm<TModel>;
+/**
+ * Factory function to define an entity form.
+ *
+ * @remarks
+ * This is a pure configuration function that helps create an entity form
+ *
+ * @param model The entity model the form is based on
+ * @param config The configuration options for the form
+ * @returns An entity form definition
+ */
+export declare function defineEntityForm<const TModel extends EntityModel>(model: TModel, config: EntityFormOptions<TModel>): EntityForm<TModel>;
+/**
+ * Factory function to define a unit form.
+ *
+ * @remarks
+ * This is a pure configuration function that helps create a unit form
+ *
+ * @param model The unit model the form is based on
+ * @param config The configuration options for the form
+ * @returns A unit form definition
+ */
+export declare function defineUnitForm<const TModel extends UnitModel>(model: TModel, config: UnitFormOptions<TModel>): UnitForm<TModel>;
+export {};

package/dist/forms.js

@@ -0,0 +1,71 @@
+// --- CORE TYPES ---
+/**
+ * The type of form being defined.
+ */
+export var FormType;
+(function (FormType) {
+    FormType["ENTITY"] = "ENTITY";
+    FormType["TRANSACTION"] = "TRANSACTION";
+    FormType["UNIT"] = "UNIT";
+})(FormType || (FormType = {}));
+// --- FACTORIES (Pure Configuration) ---
+/**
+ * Factory function to define a transaction form.
+ *
+ * @remarks
+ * This is a pure configuration function that helps create a transaction form
+ *
+ * @param model The transaction model the form is based on
+ * @param config The configuration options for the form
+ * @returns A transaction form definition
+ */
+export function defineTransactionForm(model, config) {
+    return {
+        refId: config.refId,
+        name: config.name,
+        description: config.description,
+        type: FormType.TRANSACTION,
+        modelRefId: model.refId,
+        fields: config.fields,
+    };
+}
+/**
+ * Factory function to define an entity form.
+ *
+ * @remarks
+ * This is a pure configuration function that helps create an entity form
+ *
+ * @param model The entity model the form is based on
+ * @param config The configuration options for the form
+ * @returns An entity form definition
+ */
+export function defineEntityForm(model, config) {
+    return {
+        refId: config.refId,
+        name: config.name,
+        description: config.description,
+        type: FormType.ENTITY,
+        modelRefId: model.refId,
+        fields: config.fields,
+    };
+}
+/**
+ * Factory function to define a unit form.
+ *
+ * @remarks
+ * This is a pure configuration function that helps create a unit form
+ *
+ * @param model The unit model the form is based on
+ * @param config The configuration options for the form
+ * @returns A unit form definition
+ */
+export function defineUnitForm(model, config) {
+    return {
+        refId: config.refId,
+        name: config.name,
+        description: config.description,
+        type: FormType.UNIT,
+        modelRefId: model.refId,
+        fields: config.fields,
+    };
+}

package/dist/ledgers.d.ts

@@ -1,22 +1,39 @@
-import { InferInsertModel, InferSelectModel } from "drizzle-orm";
-import * as v from "valibot";
-import { InferOutput } from "valibot";
-import { KitledgerDb } from "./db.js";
-import { FilterOperationParameters, GetOperationResult } from "./db.js";
-import { ledgers } from "./schema.js";
-export declare const LedgerCreateSchema: v.ObjectSchema<{
-    readonly ref_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 64, undefined>]>;
-    readonly alt_id: v.NullishSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 64, undefined>]>, null>;
-    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 64, undefined>]>;
-    readonly description: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
-    readonly unit_model_id: v.StringSchema<undefined>;
-    readonly active: v.NullishSchema<v.BooleanSchema<undefined>, true>;
-    readonly created_at: v.OptionalSchema<v.DateSchema<undefined>, undefined>;
-    readonly updated_at: v.OptionalSchema<v.NullableSchema<v.DateSchema<undefined>, undefined>, undefined>;
-}, undefined>;
-import { ValidationSuccess, ValidationFailure } from "./validation.js";
-export type LedgerInsert = InferInsertModel<typeof ledgers>;
-export type Ledger = InferSelectModel<typeof ledgers>;
-export type LedgerCreateData = InferOutput<typeof LedgerCreateSchema>;
-export declare function filterLedgers(db: KitledgerDb, params: FilterOperationParameters): Promise<GetOperationResult<Ledger>>;
-export declare function createLedger(db: KitledgerDb, data: LedgerCreateData): Promise<ValidationSuccess<Ledger> | ValidationFailure<LedgerCreateData>>;
+import type { UnitModel } from "./units.js";
+/**
+ * Ledger definitions and utilities.
+ *
+ * @remarks
+ * This module provides type definitions and functions for defining ledgers in the system.
+ */
+export type Ledger = {
+    refId: string;
+    name: string;
+    description?: string;
+    status: LedgerStatus;
+    baseUnitModel: string;
+};
+export declare enum LedgerStatus {
+    ACTIVE = "active",
+    INACTIVE = "inactive"
+}
+/**
+ * Options for defining a ledger.
+ *
+ * @param refId - The reference ID of the ledger.
+ * @param name - The name of the ledger.
+ * @param description - An optional description of the ledger.
+ * @param active - An optional flag indicating if the ledger is active. Defaults to true.
+ * @returns An object containing the options for the ledger.
+ */
+export type LedgerOptions = {
+    refId: string;
+    name: string;
+    description?: string;
+    status?: LedgerStatus;
+};
+/**
+ * Defines a ledger with the given options.
+ * @param options - The options for defining the ledger.
+ * @returns The defined ledger.
+ */
+export declare function defineLedger(options: LedgerOptions, baseUnitModel: UnitModel): Ledger;