@kitledger/core 0.0.2 → 0.0.3

package/dist/factories.js

@@ -0,0 +1,150 @@
+import { faker } from "@faker-js/faker";
+import { v7 } from "uuid";
+import { BalanceType } from "./accounts.js";
+/**
+ * A generic factory function to create an array of items.
+ * @param factory A function that creates a single item.
+ * @param count The number of items to create.
+ * @returns An array of created items.
+ */
+export const factory = (factory, count) => {
+    return Array.from({ length: count }, factory);
+};
+export class BaseFactory {
+    factory;
+    constructor(factory) {
+        this.factory = factory;
+    }
+    make(count) {
+        return factory(this.factory, count);
+    }
+}
+export class ApiTokenFactory extends BaseFactory {
+    constructor() {
+        super(makeApiToken);
+    }
+}
+export class PermissionFactory extends BaseFactory {
+    constructor() {
+        super(makePermission);
+    }
+}
+export class PermissionAssignmentFactory extends BaseFactory {
+    constructor() {
+        super(makePermissionAssignment);
+    }
+}
+export class RoleFactory extends BaseFactory {
+    constructor() {
+        super(makeRole);
+    }
+}
+export class SessionFactory extends BaseFactory {
+    constructor() {
+        super(makeSession);
+    }
+}
+export class SystemPermissionFactory extends BaseFactory {
+    constructor() {
+        super(makeSystemPermission);
+    }
+}
+export class UserFactory extends BaseFactory {
+    constructor() {
+        super(makeUser);
+    }
+}
+export class UserRoleFactory extends BaseFactory {
+    constructor() {
+        super(makeUserRole);
+    }
+}
+const makeApiToken = () => ({
+    id: faker.string.uuid(),
+    user_id: faker.string.uuid(),
+    name: faker.lorem.word(),
+    revoked_at: faker.datatype.boolean() ? faker.date.recent() : null,
+});
+const makePermissionAssignment = () => ({
+    id: faker.string.uuid(),
+    permission_id: faker.string.uuid(),
+    user_id: faker.datatype.boolean() ? faker.string.uuid() : null,
+    created_at: faker.date.past(),
+    updated_at: faker.date.recent(),
+    role_id: faker.datatype.boolean() ? faker.string.uuid() : null,
+});
+const makePermission = () => ({
+    id: faker.string.uuid(),
+    name: `can_${faker.word.verb()}_${faker.word.noun()}`,
+    created_at: faker.date.past(),
+    updated_at: faker.date.recent(),
+    description: faker.lorem.sentence(),
+});
+const makeRole = () => ({
+    id: faker.string.uuid(),
+    name: faker.person.jobTitle(),
+    description: faker.lorem.sentence(),
+    created_at: faker.date.past(),
+    updated_at: faker.date.recent(),
+});
+const makeSession = () => v7();
+const makeSystemPermission = () => ({
+    id: faker.string.uuid(),
+    permission: `system:${faker.word.noun()}:${faker.word.verb()}`,
+    user_id: faker.string.uuid(),
+    created_at: faker.date.past(),
+    updated_at: faker.date.recent(),
+});
+const makeUser = () => {
+    const firstName = faker.person.firstName();
+    const lastName = faker.person.lastName();
+    return {
+        id: faker.string.uuid(),
+        first_name: firstName,
+        last_name: lastName,
+        email: faker.internet.email({ firstName, lastName }),
+        password_hash: faker.internet.password({ length: 60 }),
+        created_at: faker.date.past(),
+        updated_at: faker.date.recent(),
+    };
+};
+const makeUserRole = () => ({
+    id: faker.string.uuid(),
+    user_id: faker.string.uuid(),
+    role_id: faker.string.uuid(),
+    created_at: faker.date.past(),
+    updated_at: faker.date.recent(),
+});
+export class LedgerFactory extends BaseFactory {
+    constructor() {
+        super(makeLedger);
+    }
+}
+export class AccountFactory extends BaseFactory {
+    constructor() {
+        super(makeAccount);
+    }
+}
+const makeLedger = () => ({
+    id: v7(),
+    ref_id: v7(),
+    alt_id: v7(),
+    name: faker.company.name(),
+    description: faker.company.catchPhrase(),
+    active: true,
+    created_at: faker.date.past(),
+    updated_at: faker.date.recent(),
+});
+const makeAccount = () => ({
+    id: v7(),
+    ref_id: v7(),
+    alt_id: v7(),
+    name: faker.finance.accountName(),
+    balance_type: faker.helpers.arrayElement(Object.values(BalanceType)),
+    ledger_id: v7(),
+    parent_id: v7(),
+    active: true,
+    created_at: faker.date.past(),
+    updated_at: faker.date.recent(),
+    meta: {},
+});

package/dist/fields.d.ts

@@ -0,0 +1,71 @@
+export declare enum FieldType {
+    TEXT = "text",
+    NUMBER = "number",
+    DATE = "date",
+    BOOLEAN = "boolean",
+    URL = "url",
+    SELECT = "select",
+    RELATION = "relation"
+}
+interface BaseField {
+    ref_id: string;
+    name: string;
+    description?: string;
+}
+export interface TextField extends BaseField {
+    type: FieldType.TEXT;
+    options?: {
+        maxLength?: number;
+        format?: "email" | "plain" | "rich_text";
+    };
+}
+export type NumberFormatting = {
+    style: "integer";
+} | {
+    style: "decimal";
+    precision: number;
+} | {
+    style: "currency";
+    currencyCode: string;
+};
+export interface NumberField extends BaseField {
+    type: FieldType.NUMBER;
+    options: {
+        min?: number;
+        max?: number;
+        formatting: NumberFormatting;
+    };
+}
+export interface DateField extends BaseField {
+    type: FieldType.DATE;
+    options?: {
+        includeTime: boolean;
+        formatStr: string;
+    };
+}
+export type QueryConfig = {};
+export interface SelectField extends BaseField {
+    type: FieldType.SELECT;
+    options: {
+        multiSelect: boolean;
+        items: Array<{
+            label: string;
+            value: string | number;
+            color?: string;
+        }>;
+        defaultValue?: string | number | Array<string | number>;
+    };
+}
+export interface RelationField extends BaseField {
+    type: FieldType.RELATION;
+    options: {
+        multiSelect: boolean;
+        targetEntityId: string;
+        displayFieldId: string;
+        query: QueryConfig;
+    };
+}
+export type Field = TextField | NumberField | DateField | SelectField | RelationField;
+export type FieldOptions = Field;
+export declare function defineField<T extends FieldOptions>(options: T): T;
+export {};

package/dist/fields.js

@@ -0,0 +1,13 @@
+export var FieldType;
+(function (FieldType) {
+    FieldType["TEXT"] = "text";
+    FieldType["NUMBER"] = "number";
+    FieldType["DATE"] = "date";
+    FieldType["BOOLEAN"] = "boolean";
+    FieldType["URL"] = "url";
+    FieldType["SELECT"] = "select";
+    FieldType["RELATION"] = "relation";
+})(FieldType || (FieldType = {}));
+export function defineField(options) {
+    return options;
+}

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { TransactionModel } from "./transactions.js";
 import { EntityModel } from "./entities.js";
+import { TransactionModel } from "./transactions.js";
 export interface KitledgerConfig {
     transactionModels: TransactionModel[];
     entityModels: EntityModel[];

package/dist/jwt.d.ts

@@ -0,0 +1,10 @@
+import { type JWTPayload } from "jose";
+import { AuthConfigOptions } from "./auth.js";
+export declare enum TokenType {
+    SESSION = "SESSION",
+    API = "API"
+}
+export declare function verifyToken(authConfig: AuthConfigOptions, token: string): Promise<JWTPayload>;
+export declare function signToken(authConfig: AuthConfigOptions, payload: JWTPayload): Promise<string>;
+export declare function assembleApiTokenJwtPayload(tokenId: string): JWTPayload;
+export declare function assembleSessionJwtPayload(sessionId: string): JWTPayload;

package/dist/jwt.js

@@ -0,0 +1,66 @@
+import { SignJWT, jwtVerify } from "jose";
+export var TokenType;
+(function (TokenType) {
+    TokenType["SESSION"] = "SESSION";
+    TokenType["API"] = "API";
+})(TokenType || (TokenType = {}));
+const encodeSecret = (secret) => new TextEncoder().encode(secret);
+export async function verifyToken(authConfig, token) {
+    const currentSecret = authConfig.secret;
+    try {
+        const { payload } = await jwtVerify(token, encodeSecret(currentSecret), {
+            algorithms: [authConfig.jwtAlgorithm],
+        });
+        return payload;
+    }
+    catch (currentSecretError) {
+        const pastSecrets = authConfig.pastSecrets || [];
+        if (pastSecrets.length > 0) {
+            try {
+                const decodedFromPast = await Promise.any(pastSecrets.map(async (pastSecret) => {
+                    try {
+                        const { payload } = await jwtVerify(token, encodeSecret(pastSecret), {
+                            algorithms: [authConfig.jwtAlgorithm],
+                        });
+                        return payload;
+                    }
+                    catch (err) {
+                        console.warn(`Failed to verify token with past secrets (${err instanceof Error ? err.message : String(err)}`);
+                        throw err;
+                    }
+                }));
+                return decodedFromPast;
+            }
+            catch (aggregateError) {
+                console.warn("All past secret verifications failed:", aggregateError.errors);
+            }
+        }
+        console.error("Token verification ultimately failed:", currentSecretError);
+        throw new Error("Invalid or expired token.");
+    }
+}
+export async function signToken(authConfig, payload) {
+    const currentSecret = authConfig.secret;
+    try {
+        const token = await new SignJWT(payload)
+            .setProtectedHeader({ alg: authConfig.jwtAlgorithm })
+            .sign(encodeSecret(currentSecret));
+        return token;
+    }
+    catch (error) {
+        console.error("Failed to sign token:", error);
+        throw new Error("Token signing failed.");
+    }
+}
+export function assembleApiTokenJwtPayload(tokenId) {
+    return {
+        jti: tokenId,
+        token_type: TokenType.API,
+    };
+}
+export function assembleSessionJwtPayload(sessionId) {
+    return {
+        jti: sessionId,
+        token_type: TokenType.SESSION,
+    };
+}

package/dist/ledgers.d.ts

@@ -0,0 +1,22 @@
+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>>;

package/dist/ledgers.js

@@ -0,0 +1,144 @@
+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);
+    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],
+    };
+}

package/dist/query.d.ts

@@ -0,0 +1,19 @@
+import { Query } from "@kitledger/query";
+import { PgTable } from "drizzle-orm/pg-core";
+import { Knex } from "knex";
+import { type KitledgerDb, GetOperationResult, QueryResultRow } from "./db.js";
+/**
+ * Prepares and executes a query against the specified table using the provided parameters.
+ * @param table
+ * @param params
+ * @returns
+ */
+export declare function executeQuery(db: KitledgerDb, table: PgTable, params: Query): Promise<GetOperationResult<QueryResultRow>>;
+/**
+ * Builds a Knex query object from a QueryOptions configuration.
+ * @param kx - The Knex instance.
+ * @param tableName - The name of the table to query.
+ * @param options - The QueryOptions object.
+ * @returns A Knex QueryBuilder instance.
+ */
+export declare function buildQuery(kx: Knex, tableName: string, options: Query, limit: number, offset: number): Knex.QueryBuilder;