@kitledger/core 0.0.8 → 0.0.9

package/dist/fields.js

@@ -1,3 +1,6 @@
+/**
+ * Enumeration of supported field types.
+ */
 export var FieldType;
 (function (FieldType) {
     FieldType["TEXT"] = "text";
@@ -8,6 +11,15 @@ 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) {
     const { required = false, ...rest } = options;
     return {
@@ -16,6 +28,15 @@ export function defineTextField(options) {
         ...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) {
     const { required = false, ...rest } = options;
     return {
@@ -24,6 +45,15 @@ export function defineNumberField(options) {
         ...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) {
     const { required = false, ...rest } = options;
     return {
@@ -32,6 +62,15 @@ export function defineDateField(options) {
         ...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) {
     const { required = false, ...rest } = options;
     return {
@@ -40,6 +79,11 @@ export function defineBooleanField(options) {
         ...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) {
     const { required = false, ...rest } = options;
     return {
@@ -48,6 +92,15 @@ export function defineURLField(options) {
         ...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) {
     const { required = false, ...rest } = options;
     return {
@@ -56,6 +109,15 @@ export function defineSelectField(options) {
         ...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) {
     const { required = false, ...rest } = options;
     return {

package/dist/forms.d.ts

@@ -2,22 +2,37 @@ 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;
@@ -25,6 +40,9 @@ export interface BaseForm {
     description?: string;
     fieldOrder?: string[];
 }
+/**
+ * Configuration options for entity forms
+ */
 export type EntityFormOptions<TModel extends {
     fields?: readonly any[];
 }> = {
@@ -33,6 +51,9 @@ export type EntityFormOptions<TModel extends {
     refId: string;
     fields: InferFieldConfig<NonNullable<TModel["fields"]>>;
 };
+/**
+ * Configuration options for unit forms
+ */
 export type UnitFormOptions<TModel extends {
     fields?: readonly any[];
 }> = {
@@ -41,6 +62,9 @@ export type UnitFormOptions<TModel extends {
     refId: string;
     fields: InferFieldConfig<NonNullable<TModel["fields"]>>;
 };
+/**
+ * Configuration options for transaction forms
+ */
 export type TransactionFormOptions<TModel extends {
     fields?: readonly any[];
 }> = {
@@ -49,19 +73,58 @@ export type TransactionFormOptions<TModel extends {
     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

@@ -1,4 +1,7 @@
 // --- CORE TYPES ---
+/**
+ * The type of form being defined.
+ */
 export var FormType;
 (function (FormType) {
     FormType["ENTITY"] = "ENTITY";
@@ -6,6 +9,16 @@ export var FormType;
     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,
@@ -16,6 +29,16 @@ export function defineTransactionForm(model, config) {
         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,
@@ -26,6 +49,16 @@ export function defineEntityForm(model, config) {
         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,

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;

package/dist/ledgers.js

@@ -1,144 +1,17 @@
-import { and, eq, sql } from "drizzle-orm";
-import * as v from "valibot";
-import { ANY, defaultLimit, defaultOffset, maxLimit, parseBooleanFilterValue, } from "./db.js";
-import { ledgers } from "./schema.js";
-export const LedgerCreateSchema = v.object({
-    ref_id: v.pipe(v.string(), v.maxLength(64)),
-    alt_id: v.nullish(v.pipe(v.string(), v.maxLength(64)), null),
-    name: v.pipe(v.string(), v.nonEmpty(), v.maxLength(64)),
-    description: v.nullable(v.pipe(v.string(), v.maxLength(255))),
-    unit_model_id: v.string(),
-    active: v.nullish(v.boolean(), true),
-    created_at: v.optional(v.date()),
-    updated_at: v.optional(v.nullable(v.date())),
-});
-import { v7 } from "uuid";
-import { parseValibotIssues, } from "./validation.js";
-export async function filterLedgers(db, params) {
-    const { limit = defaultLimit, offset = defaultOffset, ...filters } = params;
-    const filterConditions = [];
-    for (const [key, value] of Object.entries(filters)) {
-        if (key === ledgers.id.name && String(value).length > 0) {
-            filterConditions.push(eq(ledgers.id, String(value)));
-        }
-        if (key === ledgers.ref_id.name && String(value).length > 0) {
-            filterConditions.push(eq(ledgers.ref_id, String(value)));
-        }
-        if (key === ledgers.alt_id.name && String(value).length > 0) {
-            filterConditions.push(eq(ledgers.alt_id, String(value)));
-        }
-        if (key === ledgers.name.name && String(value).length > 0) {
-            filterConditions.push(sql `${ledgers.name} ILIKE ${"%" + String(value) + "%"}`);
-        }
-        if (key === ledgers.active.name && String(value).length > 0) {
-            if (value === ANY) {
-                continue;
-            }
-            const booleanValue = parseBooleanFilterValue(String(value));
-            if (booleanValue !== null) {
-                filterConditions.push(eq(ledgers.active, booleanValue));
-            }
-        }
-    }
-    // By default, only return active ledgers unless explicitly filtered otherwise
-    if (!Object.keys(filters).includes(ledgers.active.name)) {
-        filterConditions.push(eq(ledgers.active, true));
-    }
-    const results = await db
-        .select()
-        .from(ledgers)
-        .where(and(...filterConditions))
-        .limit(Math.min(limit, maxLimit))
-        .offset(offset);
+export var LedgerStatus;
+(function (LedgerStatus) {
+    LedgerStatus["ACTIVE"] = "active";
+    LedgerStatus["INACTIVE"] = "inactive";
+})(LedgerStatus || (LedgerStatus = {}));
+/**
+ * Defines a ledger with the given options.
+ * @param options - The options for defining the ledger.
+ * @returns The defined ledger.
+ */
+export function defineLedger(options, baseUnitModel) {
     return {
-        data: results,
-        limit: Math.min(limit, maxLimit),
-        offset: offset,
-        count: results.length,
-    };
-}
-async function refIdAlreadyExists(db, refId) {
-    const results = await db.query.ledgers.findMany({
-        where: eq(ledgers.ref_id, refId),
-        columns: { id: true },
-    });
-    return results.length > 0;
-}
-async function altIdAlreadyExists(db, altId) {
-    if (!altId) {
-        return false;
-    }
-    const results = await db.query.ledgers.findMany({
-        where: eq(ledgers.alt_id, altId),
-        columns: { id: true },
-    });
-    return results.length > 0;
-}
-async function validateLedgerCreate(db, data) {
-    const result = v.safeParse(LedgerCreateSchema, data);
-    let success = result.success;
-    if (!result.success) {
-        return {
-            success: false,
-            errors: parseValibotIssues(result.issues),
-        };
-    }
-    const errors = [];
-    const [refIdError, altIdError] = await Promise.all([
-        refIdAlreadyExists(db, data.ref_id),
-        altIdAlreadyExists(db, data.alt_id ?? null),
-    ]);
-    if (refIdError) {
-        success = false;
-        errors.push({
-            type: "data",
-            path: "ref_id",
-            message: "Ref ID already exists.",
-        });
-    }
-    if (altIdError) {
-        success = false;
-        errors.push({
-            type: "data",
-            path: "alt_id",
-            message: "Alt ID already exists.",
-        });
-    }
-    return {
-        success: success,
-        data: result.output,
-        errors: errors,
-    };
-}
-export async function createLedger(db, data) {
-    const validation = await validateLedgerCreate(db, data);
-    if (!validation.success || !validation.data) {
-        return {
-            success: false,
-            data: data,
-            errors: validation.errors,
-        };
-    }
-    const insertData = {
-        id: v7(),
-        ...validation.data,
-    };
-    const result = await db.insert(ledgers).values(insertData).returning();
-    if (result.length === 0) {
-        return {
-            success: false,
-            data: validation.data,
-            errors: [
-                {
-                    type: "data",
-                    path: null,
-                    message: "Failed to create ledger.",
-                },
-            ],
-        };
-    }
-    return {
-        success: true,
-        data: result[0],
+        ...options,
+        status: options.status ?? LedgerStatus.ACTIVE,
+        baseUnitModel: baseUnitModel.refId,
     };
 }

package/dist/main.d.ts

@@ -1,15 +1,32 @@
 import type { TransactionForm, EntityForm, UnitForm } from "./forms.js";
 import { KitledgerDb } from "./db.js";
 import { EntityModel } from "./entities.js";
+import { Ledger } from "./ledgers.js";
 import { TransactionModel } from "./transactions.js";
 import { UnitModel } from "./units.js";
+/**
+ * Type definition for the overall Kitledger configuration.
+ *
+ * @remarks
+ * Includes database instance, entity models, transaction models, unit models,
+ * and optional forms for transactions, entities, and units.
+ *
+ * @returns An object representing the Kitledger configuration.
+ */
 export interface KitledgerConfig {
     database: KitledgerDb;
+    entityForms?: EntityForm<EntityModel>[];
     entityModels: EntityModel[];
-    transactionModels: TransactionModel[];
-    unitModels: UnitModel[];
+    ledgers: Ledger[];
     transactionForms?: TransactionForm<TransactionModel>[];
-    entityForms?: EntityForm<EntityModel>[];
+    transactionModels: TransactionModel[];
     unitForms?: UnitForm<UnitModel>[];
+    unitModels: UnitModel[];
 }
+/**
+ * Factory function to define the Kitledger configuration.
+ *
+ * @param config - The Kitledger configuration object.
+ * @returns The provided Kitledger configuration.
+ */
 export declare function defineConfig(config: KitledgerConfig): KitledgerConfig;

package/dist/main.js

@@ -1,3 +1,9 @@
+/**
+ * Factory function to define the Kitledger configuration.
+ *
+ * @param config - The Kitledger configuration object.
+ * @returns The provided Kitledger configuration.
+ */
 export function defineConfig(config) {
     return config;
 }

package/dist/migrations/0003_familiar_lila_cheney.sql

@@ -0,0 +1,9 @@
+ALTER TABLE "entity_models" DISABLE ROW LEVEL SECURITY;--> statement-breakpoint
+ALTER TABLE "ledgers" DISABLE ROW LEVEL SECURITY;--> statement-breakpoint
+ALTER TABLE "transaction_models" DISABLE ROW LEVEL SECURITY;--> statement-breakpoint
+ALTER TABLE "unit_models" DISABLE ROW LEVEL SECURITY;--> statement-breakpoint
+DROP TABLE "entity_models" CASCADE;--> statement-breakpoint
+DROP TABLE "ledgers" CASCADE;--> statement-breakpoint
+DROP TABLE "transaction_models" CASCADE;--> statement-breakpoint
+DROP TABLE "unit_models" CASCADE;--> statement-breakpoint
+ALTER TABLE "accounts" ALTER COLUMN "ledger_id" SET DATA TYPE varchar(64);

package/dist/migrations/0004_magenta_hairball.sql

@@ -0,0 +1 @@
+-- Custom SQL migration file, put your code below! --