@kitledger/core 0.0.3 → 0.0.5

package/dist/entities.d.ts

@@ -1,12 +1,41 @@
+import type { Field } from "./fields.js";
 export declare enum EntityModelStatus {
     ACTIVE = 0,
     INACTIVE = 1
 }
-export type EntityModelOptions = {
+export type InferEntityMetaType<TFields extends readonly Field[]> = {
+    [K in TFields[number] as K["ref_id"]]: K["__primitive_type"];
+};
+export type Entity<TData = Record<string, any>> = {
+    id: string;
+    model_ref_id: string;
+    created_at: Date;
+    updated_at: Date;
+    data: TData;
+};
+export type EntityHook<TData> = (entity: Entity<TData>) => Promise<Entity<TData>>;
+export type EntityHooks<TData = Record<string, any>> = {
+    creating?: EntityHook<TData>[];
+    updating?: EntityHook<TData>[];
+    deleting?: EntityHook<TData>[];
+    created?: EntityHook<TData>[];
+    updated?: EntityHook<TData>[];
+    deleted?: EntityHook<TData>[];
+};
+export type EntityModel = {
+    ref_id: string;
+    alt_id?: string;
+    name: string;
+    status: EntityModelStatus;
+    fields?: Field[];
+    hooks?: EntityHooks<any>;
+};
+export type EntityModelOptions<TFields extends readonly Field[]> = {
     ref_id: string;
     alt_id?: string;
     name: string;
     status?: EntityModelStatus;
+    fields?: TFields;
+    hooks?: EntityHooks<InferEntityMetaType<TFields>>;
 };
-export type EntityModel = EntityModelOptions;
-export declare function defineEntityModel(options: EntityModelOptions): EntityModelOptions;
+export declare function defineEntityModel<const TFields extends readonly Field[]>(options: EntityModelOptions<TFields>): EntityModel;

package/dist/entities.js

@@ -4,5 +4,11 @@ export var EntityModelStatus;
     EntityModelStatus[EntityModelStatus["INACTIVE"] = 1] = "INACTIVE";
 })(EntityModelStatus || (EntityModelStatus = {}));
 export function defineEntityModel(options) {
-    return options;
+    const entityModel = {
+        ...options,
+        status: options.status ?? EntityModelStatus.ACTIVE,
+        fields: options.fields,
+        hooks: options.hooks,
+    };
+    return entityModel;
 }

package/dist/fields.d.ts

@@ -8,16 +8,15 @@ export declare enum FieldType {
     RELATION = "relation"
 }
 interface BaseField {
-    ref_id: string;
+    readonly ref_id: string;
     name: string;
     description?: string;
 }
 export interface TextField extends BaseField {
     type: FieldType.TEXT;
-    options?: {
-        maxLength?: number;
-        format?: "email" | "plain" | "rich_text";
-    };
+    readonly __primitive_type?: string;
+    maxLength?: number;
+    format?: "email" | "plain" | "rich_text";
 }
 export type NumberFormatting = {
     style: "integer";
@@ -30,42 +29,88 @@ export type NumberFormatting = {
 };
 export interface NumberField extends BaseField {
     type: FieldType.NUMBER;
-    options: {
-        min?: number;
-        max?: number;
-        formatting: NumberFormatting;
-    };
+    readonly __primitive_type?: number;
+    min?: number;
+    max?: number;
+    formatting: NumberFormatting;
 }
 export interface DateField extends BaseField {
     type: FieldType.DATE;
-    options?: {
-        includeTime: boolean;
-        formatStr: string;
-    };
+    readonly __primitive_type?: Date;
+    includeTime: boolean;
+    formatStr: string;
+}
+export interface BooleanField extends BaseField {
+    type: FieldType.BOOLEAN;
+    readonly __primitive_type?: boolean;
+    defaultValue?: boolean;
+}
+export interface URLField extends BaseField {
+    type: FieldType.URL;
+    readonly __primitive_type?: string;
+    defaultValue?: 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>;
-    };
+    readonly __primitive_type?: string | number | (string | number)[];
+    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;
-    };
+    readonly __primitive_type?: any;
+    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 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;
+}): TextField & {
+    ref_id: T;
+};
+export declare function defineNumberField<const T extends string>(options: NumberFieldOptions & {
+    ref_id: T;
+}): NumberField & {
+    ref_id: T;
+};
+export declare function defineDateField<const T extends string>(options: DateFieldOptions & {
+    ref_id: T;
+}): DateField & {
+    ref_id: T;
+};
+export declare function defineBooleanField<const T extends string>(options: BooleanFieldOptions & {
+    ref_id: T;
+}): BooleanField & {
+    ref_id: T;
+};
+export declare function defineURLField<const T extends string>(options: URLFieldOptions & {
+    ref_id: T;
+}): URLField & {
+    ref_id: T;
+};
+export declare function defineSelectField<const T extends string>(options: SelectFieldOptions & {
+    ref_id: T;
+}): SelectField & {
+    ref_id: T;
+};
+export declare function defineRelationField<const T extends string>(options: RelationFieldOptions & {
+    ref_id: T;
+}): RelationField & {
+    ref_id: T;
+};
 export {};

package/dist/fields.js

@@ -8,6 +8,24 @@ export var FieldType;
     FieldType["SELECT"] = "select";
     FieldType["RELATION"] = "relation";
 })(FieldType || (FieldType = {}));
-export function defineField(options) {
-    return options;
+export function defineTextField(options) {
+    return { type: FieldType.TEXT, ...options };
+}
+export function defineNumberField(options) {
+    return { type: FieldType.NUMBER, ...options };
+}
+export function defineDateField(options) {
+    return { type: FieldType.DATE, ...options };
+}
+export function defineBooleanField(options) {
+    return { type: FieldType.BOOLEAN, ...options };
+}
+export function defineURLField(options) {
+    return { type: FieldType.URL, ...options };
+}
+export function defineSelectField(options) {
+    return { type: FieldType.SELECT, ...options };
+}
+export function defineRelationField(options) {
+    return { type: FieldType.RELATION, ...options };
 }

package/dist/transactions.d.ts

@@ -1,33 +1,41 @@
+import type { Field } from "./fields.js";
 export declare enum TransactionModelStatus {
     ACTIVE = 0,
-    INACTIVE = 1,
-    FROZEN = 2
+    INACTIVE = 1
 }
-export type Transaction<T = Record<string, any>> = {
+export type InferTransactionMetaType<TFields extends readonly Field[]> = {
+    [K in TFields[number] as K["ref_id"]]: K["__primitive_type"];
+};
+export type Transaction<TData = Record<string, any>> = {
     id: string;
     model_ref_id: string;
     created_at: Date;
     updated_at: Date;
-    data: T;
+    data: TData;
+};
+export type TransactionHook<TData> = (transaction: Transaction<TData>) => Promise<Transaction<TData>>;
+export type TransactionHooks<TData = Record<string, any>> = {
+    creating?: TransactionHook<TData>[];
+    updating?: TransactionHook<TData>[];
+    deleting?: TransactionHook<TData>[];
+    created?: TransactionHook<TData>[];
+    updated?: TransactionHook<TData>[];
+    deleted?: TransactionHook<TData>[];
 };
-export type TransactionPipe<T> = (transaction: Transaction<T>) => Promise<Transaction<T> | void>;
-export type TransactionListener<T> = (transaction: Readonly<Transaction<T>>) => Promise<void>;
-export type TransactionModel<T = Record<string, any>> = {
+export type TransactionModel = {
     ref_id: string;
     alt_id?: string;
     name: string;
     status: TransactionModelStatus;
-    hooks?: {
-        creating?: TransactionPipe<T>[];
-        updating?: TransactionPipe<T>[];
-        created?: TransactionListener<T>[];
-        updated?: TransactionListener<T>[];
-    };
+    fields?: Field[];
+    hooks?: TransactionHooks<any>;
 };
-export type TransactionModelOptions = {
+export type TransactionModelOptions<TFields extends readonly Field[]> = {
     ref_id: string;
     alt_id?: string;
     name: string;
     status?: TransactionModelStatus;
+    fields?: TFields;
+    hooks?: TransactionHooks<InferTransactionMetaType<TFields>>;
 };
-export declare function defineTransactionModel(options: TransactionModelOptions): TransactionModel;
+export declare function defineTransactionModel<const TFields extends readonly Field[]>(options: TransactionModelOptions<TFields>): TransactionModel;

package/dist/transactions.js

@@ -2,12 +2,13 @@ export var TransactionModelStatus;
 (function (TransactionModelStatus) {
     TransactionModelStatus[TransactionModelStatus["ACTIVE"] = 0] = "ACTIVE";
     TransactionModelStatus[TransactionModelStatus["INACTIVE"] = 1] = "INACTIVE";
-    TransactionModelStatus[TransactionModelStatus["FROZEN"] = 2] = "FROZEN";
 })(TransactionModelStatus || (TransactionModelStatus = {}));
 export function defineTransactionModel(options) {
     const transactionModel = {
         ...options,
         status: options.status ?? TransactionModelStatus.ACTIVE,
+        fields: options.fields,
+        hooks: options.hooks,
     };
     return transactionModel;
 }

package/dist/units.d.ts

@@ -0,0 +1,41 @@
+import type { Field } from "./fields.js";
+export declare enum UnitModelStatus {
+    ACTIVE = 0,
+    INACTIVE = 1
+}
+export type InferUnitMetaType<TFields extends readonly Field[]> = {
+    [K in TFields[number] as K["ref_id"]]: K["__primitive_type"];
+};
+export type Unit<TData = Record<string, any>> = {
+    id: string;
+    model_ref_id: string;
+    created_at: Date;
+    updated_at: Date;
+    data: TData;
+};
+export type UnitHook<TData> = (unit: Unit<TData>) => Promise<Unit<TData>>;
+export type UnitHooks<TData = Record<string, any>> = {
+    creating?: UnitHook<TData>[];
+    updating?: UnitHook<TData>[];
+    deleting?: UnitHook<TData>[];
+    created?: UnitHook<TData>[];
+    updated?: UnitHook<TData>[];
+    deleted?: UnitHook<TData>[];
+};
+export type UnitModel = {
+    ref_id: string;
+    alt_id?: string;
+    name: string;
+    status: UnitModelStatus;
+    fields?: Field[];
+    hooks?: UnitHooks<any>;
+};
+export type UnitModelOptions<TFields extends readonly Field[]> = {
+    ref_id: string;
+    alt_id?: string;
+    name: string;
+    status?: UnitModelStatus;
+    fields?: TFields;
+    hooks?: UnitHooks<InferUnitMetaType<TFields>>;
+};
+export declare function defineUnitModel<const TFields extends readonly Field[]>(options: UnitModelOptions<TFields>): UnitModel;

package/dist/units.js

@@ -0,0 +1,14 @@
+export var UnitModelStatus;
+(function (UnitModelStatus) {
+    UnitModelStatus[UnitModelStatus["ACTIVE"] = 0] = "ACTIVE";
+    UnitModelStatus[UnitModelStatus["INACTIVE"] = 1] = "INACTIVE";
+})(UnitModelStatus || (UnitModelStatus = {}));
+export function defineUnitModel(options) {
+    const unitModel = {
+        ...options,
+        status: options.status ?? UnitModelStatus.ACTIVE,
+        fields: options.fields,
+        hooks: options.hooks,
+    };
+    return unitModel;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitledger/core",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "private": false,
   "license": "Apache-2.0",
   "type": "module",
@@ -13,6 +13,10 @@
       "types": "./dist/entities.d.ts",
       "default": "./dist/entities.js"
     },
+    "./fields": {
+      "types": "./dist/fields.d.ts",
+      "default": "./dist/fields.js"
+    },
     "./transactions": {
       "types": "./dist/transactions.d.ts",
       "default": "./dist/transactions.js"
@@ -20,9 +24,14 @@
     "./ui": {
       "types": "./dist/ui.d.ts",
       "default": "./dist/ui.js"
+    },
+    "./units": {
+      "types": "./dist/units.d.ts",
+      "default": "./dist/units.js"
     }
   },
   "files": [
+    "!dist/**/*.test.js",
     "dist"
   ],
   "dependencies": {
@@ -33,15 +42,13 @@
     "pg": "^8.16.3",
     "postgres": "^3.4.7",
     "uuid": "^13.0.0",
+    "valibot": "^1.1.0",
     "@kitledger/query": "0.0.15"
   },
   "devDependencies": {
     "@faker-js/faker": "^10.1.0",
     "drizzle-kit": "^0.31.8"
   },
-  "peerDependencies": {
-    "valibot": "^1.1.0"
-  },
   "publishConfig": {
     "access": "public"
   },