simplentity 0.1.2 → 1.0.0-alpha.1

package/README.md

@@ -16,28 +16,27 @@ npm install simplentity
 ## Usage
 
 ```typescript
-import {entity, number, string, boolean} from 'simplentity';
+import {createEntity, number, string, boolean} from 'simplentity';
 
 // Define a user entity
-class User extends entity({
+const userFactory = createEntity({
   id: string().defaultFn(() => randomUUID()), // randomUUID is a third-party library. Not included.
   name: string(),
   age: number().notRequired(),
   isActive: boolean().default(true),
-}) {
-  activate(): void {
+}, ({ set }) => ({
+  activate: () => {
     // You can get suggestions for the properties of the entity.
-    this.set('isActive', true);
+    set('isActive', true)
+  },
+  deactivate: () => {
+    set('isActive', false)
   }
-  
-  deactivate(): void {
-    this.set('isActive', false);
-  }
-}
+}))
 
 // Properties that have NotRequired or Default(Fn) are optional.
 // If a property has a default value, it is automatically assigned to the property when you create the entity instance.
-const user = new User({
+const user = userFactory.create({
   name: 'John Doe',
 })
 /*

package/dist/bun/entity.d.ts

@@ -14,29 +14,59 @@ type EntityPropInputResolver<T extends EntityConfig> = {
 } & {
     [K in keyof Omit<T, RequiredFieldKeys<T>>]?: FieldTypeResolver<T[K]>;
 };
+type MethodDefinition = {
+    [key: string]: (...args: any[]) => any;
+};
+interface EntityInterface<C extends EntityConfig> {
+    get: <K extends keyof C>(key: K) => EntityConfigTypeResolver<C>[K];
+    toJSON: () => EntityConfigTypeResolver<C>;
+}
+declare class EntityFactory<C extends EntityConfig, D extends MethodDefinition> {
+    private readonly fields;
+    private readonly methodDefinitionFunction?;
+    readonly $infer: EntityInterface<C> & D;
+    constructor(fields: C, methodDefinitionFunction?: (params: {
+        set: <K extends keyof C>(key: K, value: EntityConfigTypeResolver<C>[K]) => void;
+        get: <K extends keyof C>(key: K) => EntityConfigTypeResolver<C>[K];
+    }) => D);
+    create(props: EntityPropInputResolver<C>): EntityInterface<C> & D;
+}
 /**
- * Create an entity class with the given fields
- * @param fields
+ * Creates an entity factory function that allows defining fields and optional methods for an entity.
+ * The returned factory provides a `create` method to instantiate entities with the specified fields
+ * and methods, while also supporting default values and runtime property manipulation.
+ *
+ * @template C - The configuration type for the entity fields.
+ * @template D - The type of the methods defined for the entity.
+ *
+ * @param fields - An object defining the fields of the entity. Each field should include its configuration
+ *                 and a method to retrieve its default value.
+ * @param methodDefinitionFunction - An optional function that defines additional methods for the entity.
+ *                                   It receives an object with `set` and `get` functions to manipulate
+ *                                   the entity's properties.
+ *
+ * @returns An object with a `create` method. The `create` method accepts an input object to initialize
+ *          the entity's properties and returns an entity instance with the defined fields, methods,
+ *          and utility functions (`get`, `set`, `toJSON`).
+ *
+ * @example
+ * ```typescript
+ * const userFactory = createEntity({
+ *   name: string(),
+ *   age: number().default(18),
+ *   isActive: boolean().default(true),
+ * }, ({ set, get }) => ({
+ *   incrementAge: () => set('age', get('age') + 1),
+ * }));
+ *
+ * const user = userFactory.create({ name: 'John' });
+ * console.log(user.props); // { name: 'John', age: 18, isActive: true }
+ * user.incrementAge();
+ * console.log(user.props.age); // 19
+ * ```
  */
-export declare const entity: <Config extends EntityConfig>(fields: Config) => {
-    new (props: EntityPropInputResolver<Config>): {
-        readonly "__#1@#entityConfig": Config;
-        "__#1@#props": EntityConfigTypeResolver<Config>;
-        /**
-         * Get the value of the field by key
-         * @param key
-         */
-        get<K extends keyof Config>(key: K): EntityConfigTypeResolver<Config>[K];
-        /**
-         * Set the value of the field by key
-         *
-         * WARNING: This method should be called only from the methods of the entity.
-         * Its accessor should be protected but TypeScript declaration does not allow protected methods in exported classes.
-         * @param key
-         * @param value
-         */
-        set<K extends keyof Config>(key: K, value: EntityConfigTypeResolver<Config>[K]): void;
-        toJSON(): EntityConfigTypeResolver<Config>;
-    };
-};
+export declare function createEntity<C extends EntityConfig, D extends MethodDefinition>(fields: C, methodDefinitionFunction?: (params: {
+    set: <K extends keyof C>(key: K, value: EntityConfigTypeResolver<C>[K]) => void;
+    get: <K extends keyof C>(key: K) => EntityConfigTypeResolver<C>[K];
+}) => D): EntityFactory<C, D>;
 export {};

package/dist/bun/field.d.ts

@@ -24,7 +24,7 @@ type HasDefault<T extends ConfigurableFieldBase<unknown>> = T & {
 };
 export declare abstract class Field<T> implements ConfigurableFieldBase<T> {
     _: FieldConfig<T>;
-    protected config: FieldRuntimeConfig<T>;
+    config: FieldRuntimeConfig<T>;
     constructor();
     notRequired(): NotRequired<this>;
     default(value: T): HasDefault<this>;

package/dist/bun/index.d.ts

@@ -1,3 +1,3 @@
-import { entity } from "./entity.ts";
-import { boolean, date, number, string } from "./fields/index.ts";
-export { entity, string, number, boolean, date };
+import { createEntity } from "./entity.ts";
+import { boolean, date, number, string, entity } from "./fields/index.ts";
+export { createEntity, string, number, boolean, date, entity };

package/dist/bun/index.js

@@ -1,2 +1,2 @@
 // @bun
-class f{#u;#t;constructor(t,o){this.#u=o,Object.freeze(this.#u),this.#t=Object.entries(o).reduce((e,[n,a])=>{let r=t[n]??a.getDefaultValue();if(a.getConfig().hasDefault&&r===void 0)throw new Error(`The field "${n}" has a default value but undefined was provided.`);return e[n]=r,e},{})}get(t){return this.#t[t]}set(t,o){this.#t[t]=o}toJSON(){return this.#t}}var R=(t)=>{return class extends f{constructor(o){super(o,t)}}};class u{config;constructor(){this.config={notRequired:!1,hasDefault:!1,default:void 0}}notRequired(){return this.config.notRequired=!0,this}default(t){return this.config.default=t,this.config.hasDefault=!0,this}defaultFn(t){return this.config.defaultFn=t,this.config.hasDefault=!0,this}getConfig(){return this.config}getDefaultValue(){return this.config.default??this.config.defaultFn?.()}}class i extends u{}var s=()=>{return new i};class h extends u{}var T=()=>{return new h};class g extends u{}var m=()=>{return new g};class d extends u{}var l=()=>{return new d};export{l as string,m as number,R as entity,T as date,s as boolean};
+class _{fields;methodDefinitionFunction;constructor(u,R){this.fields=u,this.methodDefinitionFunction=R}create(u){let R=Object.entries(this.fields).reduce((q,[x,C])=>{let D=u[x]??C.getDefaultValue();if(C.getConfig().hasDefault&&D===void 0)q[x]=C.getDefaultValue();else q[x]=D;return q},{}),W=(q,x)=>{R[q]=x},H=(q)=>{return R[q]},X=()=>{return R},Y=this.methodDefinitionFunction?.({set:W,get:H})??{};return{get:H,toJSON:X,...Y}}}function Z(u,R){return new _(u,R)}class T{config;constructor(){this.config={notRequired:!1,hasDefault:!1,default:void 0}}notRequired(){return this.config.notRequired=!0,this}default(u){return this.config.default=u,this.config.hasDefault=!0,this}defaultFn(u){return this.config.defaultFn=u,this.config.hasDefault=!0,this}getConfig(){return this.config}getDefaultValue(){return this.config.default??this.config.defaultFn?.()}}class b extends T{}var f=()=>{return new b};class B extends T{}var V=()=>{return new B};class G extends T{}var K=()=>{return new G};class L extends T{}var M=()=>{return new L};class Q extends T{}var U=()=>{return new Q};export{M as string,K as number,U as entity,V as date,Z as createEntity,f as boolean};

package/dist/cjs/entity.cjs

@@ -20,58 +20,50 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/entity.ts
 var entity_exports = {};
 __export(entity_exports, {
-  entity: () => entity
+  createEntity: () => createEntity
 });
 module.exports = __toCommonJS(entity_exports);
-var Entity = class {
-  #entityConfig;
-  #props;
-  constructor(props, entityConfig) {
-    this.#entityConfig = entityConfig;
-    Object.freeze(this.#entityConfig);
-    this.#props = Object.entries(entityConfig).reduce(
+var EntityFactory = class {
+  fields;
+  methodDefinitionFunction;
+  constructor(fields, methodDefinitionFunction) {
+    this.fields = fields;
+    this.methodDefinitionFunction = methodDefinitionFunction;
+  }
+  create(props) {
+    const assignedProps = Object.entries(this.fields).reduce(
       (acc, [key, field]) => {
         const value = props[key] ?? field.getDefaultValue();
         if (field.getConfig().hasDefault && value === void 0) {
-          throw new Error(`The field "${key}" has a default value but undefined was provided.`);
+          acc[key] = field.getDefaultValue();
+        } else {
+          acc[key] = value;
         }
-        acc[key] = value;
         return acc;
       },
       {}
     );
+    const set = (key, value) => {
+      assignedProps[key] = value;
+    };
+    const get = (key) => {
+      return assignedProps[key];
+    };
+    const toJSON = () => {
+      return assignedProps;
+    };
+    const methods = this.methodDefinitionFunction?.({ set, get }) ?? {};
+    return {
+      get,
+      toJSON,
+      ...methods
+    };
   }
-  /**
-   * Get the value of the field by key
-   * @param key
-   */
-  get(key) {
-    return this.#props[key];
-  }
-  /**
-   * Set the value of the field by key
-   *
-   * WARNING: This method should be called only from the methods of the entity.
-   * Its accessor should be protected but TypeScript declaration does not allow protected methods in exported classes.
-   * @param key
-   * @param value
-   */
-  set(key, value) {
-    this.#props[key] = value;
-  }
-  // biome-ignore lint/style/useNamingConvention: toJSON is a name to be used in JSON.stringify
-  toJSON() {
-    return this.#props;
-  }
-};
-var entity = (fields) => {
-  return class extends Entity {
-    constructor(props) {
-      super(props, fields);
-    }
-  };
 };
+function createEntity(fields, methodDefinitionFunction) {
+  return new EntityFactory(fields, methodDefinitionFunction);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  entity
+  createEntity
 });

package/dist/cjs/entity.d.ts

@@ -14,29 +14,59 @@ type EntityPropInputResolver<T extends EntityConfig> = {
 } & {
     [K in keyof Omit<T, RequiredFieldKeys<T>>]?: FieldTypeResolver<T[K]>;
 };
+type MethodDefinition = {
+    [key: string]: (...args: any[]) => any;
+};
+interface EntityInterface<C extends EntityConfig> {
+    get: <K extends keyof C>(key: K) => EntityConfigTypeResolver<C>[K];
+    toJSON: () => EntityConfigTypeResolver<C>;
+}
+declare class EntityFactory<C extends EntityConfig, D extends MethodDefinition> {
+    private readonly fields;
+    private readonly methodDefinitionFunction?;
+    readonly $infer: EntityInterface<C> & D;
+    constructor(fields: C, methodDefinitionFunction?: (params: {
+        set: <K extends keyof C>(key: K, value: EntityConfigTypeResolver<C>[K]) => void;
+        get: <K extends keyof C>(key: K) => EntityConfigTypeResolver<C>[K];
+    }) => D);
+    create(props: EntityPropInputResolver<C>): EntityInterface<C> & D;
+}
 /**
- * Create an entity class with the given fields
- * @param fields
+ * Creates an entity factory function that allows defining fields and optional methods for an entity.
+ * The returned factory provides a `create` method to instantiate entities with the specified fields
+ * and methods, while also supporting default values and runtime property manipulation.
+ *
+ * @template C - The configuration type for the entity fields.
+ * @template D - The type of the methods defined for the entity.
+ *
+ * @param fields - An object defining the fields of the entity. Each field should include its configuration
+ *                 and a method to retrieve its default value.
+ * @param methodDefinitionFunction - An optional function that defines additional methods for the entity.
+ *                                   It receives an object with `set` and `get` functions to manipulate
+ *                                   the entity's properties.
+ *
+ * @returns An object with a `create` method. The `create` method accepts an input object to initialize
+ *          the entity's properties and returns an entity instance with the defined fields, methods,
+ *          and utility functions (`get`, `set`, `toJSON`).
+ *
+ * @example
+ * ```typescript
+ * const userFactory = createEntity({
+ *   name: string(),
+ *   age: number().default(18),
+ *   isActive: boolean().default(true),
+ * }, ({ set, get }) => ({
+ *   incrementAge: () => set('age', get('age') + 1),
+ * }));
+ *
+ * const user = userFactory.create({ name: 'John' });
+ * console.log(user.props); // { name: 'John', age: 18, isActive: true }
+ * user.incrementAge();
+ * console.log(user.props.age); // 19
+ * ```
  */
-export declare const entity: <Config extends EntityConfig>(fields: Config) => {
-    new (props: EntityPropInputResolver<Config>): {
-        readonly "__#1@#entityConfig": Config;
-        "__#1@#props": EntityConfigTypeResolver<Config>;
-        /**
-         * Get the value of the field by key
-         * @param key
-         */
-        get<K extends keyof Config>(key: K): EntityConfigTypeResolver<Config>[K];
-        /**
-         * Set the value of the field by key
-         *
-         * WARNING: This method should be called only from the methods of the entity.
-         * Its accessor should be protected but TypeScript declaration does not allow protected methods in exported classes.
-         * @param key
-         * @param value
-         */
-        set<K extends keyof Config>(key: K, value: EntityConfigTypeResolver<Config>[K]): void;
-        toJSON(): EntityConfigTypeResolver<Config>;
-    };
-};
+export declare function createEntity<C extends EntityConfig, D extends MethodDefinition>(fields: C, methodDefinitionFunction?: (params: {
+    set: <K extends keyof C>(key: K, value: EntityConfigTypeResolver<C>[K]) => void;
+    get: <K extends keyof C>(key: K) => EntityConfigTypeResolver<C>[K];
+}) => D): EntityFactory<C, D>;
 export {};

package/dist/cjs/field.d.ts

@@ -24,7 +24,7 @@ type HasDefault<T extends ConfigurableFieldBase<unknown>> = T & {
 };
 export declare abstract class Field<T> implements ConfigurableFieldBase<T> {
     _: FieldConfig<T>;
-    protected config: FieldRuntimeConfig<T>;
+    config: FieldRuntimeConfig<T>;
     constructor();
     notRequired(): NotRequired<this>;
     default(value: T): HasDefault<this>;

package/dist/cjs/fields/entity.cjs

@@ -0,0 +1,68 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/fields/entity.ts
+var entity_exports = {};
+__export(entity_exports, {
+  entity: () => entity
+});
+module.exports = __toCommonJS(entity_exports);
+
+// src/field.ts
+var Field = class {
+  config;
+  constructor() {
+    this.config = {
+      notRequired: false,
+      hasDefault: false,
+      default: void 0
+    };
+  }
+  notRequired() {
+    this.config.notRequired = true;
+    return this;
+  }
+  default(value) {
+    this.config.default = value;
+    this.config.hasDefault = true;
+    return this;
+  }
+  defaultFn(fn) {
+    this.config.defaultFn = fn;
+    this.config.hasDefault = true;
+    return this;
+  }
+  getConfig() {
+    return this.config;
+  }
+  getDefaultValue() {
+    return this.config.default ?? this.config.defaultFn?.();
+  }
+};
+
+// src/fields/entity.ts
+var EntityField = class extends Field {
+};
+var entity = () => {
+  return new EntityField();
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  entity
+});

package/dist/cjs/fields/index.cjs

@@ -22,6 +22,7 @@ var fields_exports = {};
 __export(fields_exports, {
   boolean: () => boolean,
   date: () => date,
+  entity: () => entity,
   number: () => number,
   string: () => string
 });
@@ -86,10 +87,18 @@ var StringField = class extends Field {
 var string = () => {
   return new StringField();
 };
+
+// src/fields/entity.ts
+var EntityField = class extends Field {
+};
+var entity = () => {
+  return new EntityField();
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   boolean,
   date,
+  entity,
   number,
   string
 });

package/dist/cjs/index.cjs

@@ -21,6 +21,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   boolean: () => boolean,
+  createEntity: () => createEntity,
   date: () => date,
   entity: () => entity,
   number: () => number,
@@ -29,54 +30,46 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/entity.ts
-var Entity = class {
-  #entityConfig;
-  #props;
-  constructor(props, entityConfig) {
-    this.#entityConfig = entityConfig;
-    Object.freeze(this.#entityConfig);
-    this.#props = Object.entries(entityConfig).reduce(
+var EntityFactory = class {
+  fields;
+  methodDefinitionFunction;
+  constructor(fields, methodDefinitionFunction) {
+    this.fields = fields;
+    this.methodDefinitionFunction = methodDefinitionFunction;
+  }
+  create(props) {
+    const assignedProps = Object.entries(this.fields).reduce(
       (acc, [key, field]) => {
         const value = props[key] ?? field.getDefaultValue();
         if (field.getConfig().hasDefault && value === void 0) {
-          throw new Error(`The field "${key}" has a default value but undefined was provided.`);
+          acc[key] = field.getDefaultValue();
+        } else {
+          acc[key] = value;
         }
-        acc[key] = value;
         return acc;
       },
       {}
     );
+    const set = (key, value) => {
+      assignedProps[key] = value;
+    };
+    const get = (key) => {
+      return assignedProps[key];
+    };
+    const toJSON = () => {
+      return assignedProps;
+    };
+    const methods = this.methodDefinitionFunction?.({ set, get }) ?? {};
+    return {
+      get,
+      toJSON,
+      ...methods
+    };
   }
-  /**
-   * Get the value of the field by key
-   * @param key
-   */
-  get(key) {
-    return this.#props[key];
-  }
-  /**
-   * Set the value of the field by key
-   *
-   * WARNING: This method should be called only from the methods of the entity.
-   * Its accessor should be protected but TypeScript declaration does not allow protected methods in exported classes.
-   * @param key
-   * @param value
-   */
-  set(key, value) {
-    this.#props[key] = value;
-  }
-  // biome-ignore lint/style/useNamingConvention: toJSON is a name to be used in JSON.stringify
-  toJSON() {
-    return this.#props;
-  }
-};
-var entity = (fields) => {
-  return class extends Entity {
-    constructor(props) {
-      super(props, fields);
-    }
-  };
 };
+function createEntity(fields, methodDefinitionFunction) {
+  return new EntityFactory(fields, methodDefinitionFunction);
+}
 
 // src/field.ts
 var Field = class {
@@ -137,9 +130,17 @@ var StringField = class extends Field {
 var string = () => {
   return new StringField();
 };
+
+// src/fields/entity.ts
+var EntityField = class extends Field {
+};
+var entity = () => {
+  return new EntityField();
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   boolean,
+  createEntity,
   date,
   entity,
   number,

package/dist/cjs/index.d.ts

@@ -1,3 +1,3 @@
-import { entity } from "./entity.ts";
-import { boolean, date, number, string } from "./fields/index.ts";
-export { entity, string, number, boolean, date };
+import { createEntity } from "./entity.ts";
+import { boolean, date, number, string, entity } from "./fields/index.ts";
+export { createEntity, string, number, boolean, date, entity };

package/dist/entity.d.ts

@@ -14,29 +14,59 @@ type EntityPropInputResolver<T extends EntityConfig> = {
 } & {
     [K in keyof Omit<T, RequiredFieldKeys<T>>]?: FieldTypeResolver<T[K]>;
 };
+type MethodDefinition = {
+    [key: string]: (...args: any[]) => any;
+};
+interface EntityInterface<C extends EntityConfig> {
+    get: <K extends keyof C>(key: K) => EntityConfigTypeResolver<C>[K];
+    toJSON: () => EntityConfigTypeResolver<C>;
+}
+declare class EntityFactory<C extends EntityConfig, D extends MethodDefinition> {
+    private readonly fields;
+    private readonly methodDefinitionFunction?;
+    readonly $infer: EntityInterface<C> & D;
+    constructor(fields: C, methodDefinitionFunction?: (params: {
+        set: <K extends keyof C>(key: K, value: EntityConfigTypeResolver<C>[K]) => void;
+        get: <K extends keyof C>(key: K) => EntityConfigTypeResolver<C>[K];
+    }) => D);
+    create(props: EntityPropInputResolver<C>): EntityInterface<C> & D;
+}
 /**
- * Create an entity class with the given fields
- * @param fields
+ * Creates an entity factory function that allows defining fields and optional methods for an entity.
+ * The returned factory provides a `create` method to instantiate entities with the specified fields
+ * and methods, while also supporting default values and runtime property manipulation.
+ *
+ * @template C - The configuration type for the entity fields.
+ * @template D - The type of the methods defined for the entity.
+ *
+ * @param fields - An object defining the fields of the entity. Each field should include its configuration
+ *                 and a method to retrieve its default value.
+ * @param methodDefinitionFunction - An optional function that defines additional methods for the entity.
+ *                                   It receives an object with `set` and `get` functions to manipulate
+ *                                   the entity's properties.
+ *
+ * @returns An object with a `create` method. The `create` method accepts an input object to initialize
+ *          the entity's properties and returns an entity instance with the defined fields, methods,
+ *          and utility functions (`get`, `set`, `toJSON`).
+ *
+ * @example
+ * ```typescript
+ * const userFactory = createEntity({
+ *   name: string(),
+ *   age: number().default(18),
+ *   isActive: boolean().default(true),
+ * }, ({ set, get }) => ({
+ *   incrementAge: () => set('age', get('age') + 1),
+ * }));
+ *
+ * const user = userFactory.create({ name: 'John' });
+ * console.log(user.props); // { name: 'John', age: 18, isActive: true }
+ * user.incrementAge();
+ * console.log(user.props.age); // 19
+ * ```
  */
-export declare const entity: <Config extends EntityConfig>(fields: Config) => {
-    new (props: EntityPropInputResolver<Config>): {
-        readonly "__#1@#entityConfig": Config;
-        "__#1@#props": EntityConfigTypeResolver<Config>;
-        /**
-         * Get the value of the field by key
-         * @param key
-         */
-        get<K extends keyof Config>(key: K): EntityConfigTypeResolver<Config>[K];
-        /**
-         * Set the value of the field by key
-         *
-         * WARNING: This method should be called only from the methods of the entity.
-         * Its accessor should be protected but TypeScript declaration does not allow protected methods in exported classes.
-         * @param key
-         * @param value
-         */
-        set<K extends keyof Config>(key: K, value: EntityConfigTypeResolver<Config>[K]): void;
-        toJSON(): EntityConfigTypeResolver<Config>;
-    };
-};
+export declare function createEntity<C extends EntityConfig, D extends MethodDefinition>(fields: C, methodDefinitionFunction?: (params: {
+    set: <K extends keyof C>(key: K, value: EntityConfigTypeResolver<C>[K]) => void;
+    get: <K extends keyof C>(key: K) => EntityConfigTypeResolver<C>[K];
+}) => D): EntityFactory<C, D>;
 export {};

package/dist/entity.js

@@ -1,52 +1,44 @@
 // src/entity.ts
-var Entity = class {
-  #entityConfig;
-  #props;
-  constructor(props, entityConfig) {
-    this.#entityConfig = entityConfig;
-    Object.freeze(this.#entityConfig);
-    this.#props = Object.entries(entityConfig).reduce(
+var EntityFactory = class {
+  fields;
+  methodDefinitionFunction;
+  constructor(fields, methodDefinitionFunction) {
+    this.fields = fields;
+    this.methodDefinitionFunction = methodDefinitionFunction;
+  }
+  create(props) {
+    const assignedProps = Object.entries(this.fields).reduce(
       (acc, [key, field]) => {
         const value = props[key] ?? field.getDefaultValue();
         if (field.getConfig().hasDefault && value === void 0) {
-          throw new Error(`The field "${key}" has a default value but undefined was provided.`);
+          acc[key] = field.getDefaultValue();
+        } else {
+          acc[key] = value;
         }
-        acc[key] = value;
         return acc;
       },
       {}
     );
+    const set = (key, value) => {
+      assignedProps[key] = value;
+    };
+    const get = (key) => {
+      return assignedProps[key];
+    };
+    const toJSON = () => {
+      return assignedProps;
+    };
+    const methods = this.methodDefinitionFunction?.({ set, get }) ?? {};
+    return {
+      get,
+      toJSON,
+      ...methods
+    };
   }
-  /**
-   * Get the value of the field by key
-   * @param key
-   */
-  get(key) {
-    return this.#props[key];
-  }
-  /**
-   * Set the value of the field by key
-   *
-   * WARNING: This method should be called only from the methods of the entity.
-   * Its accessor should be protected but TypeScript declaration does not allow protected methods in exported classes.
-   * @param key
-   * @param value
-   */
-  set(key, value) {
-    this.#props[key] = value;
-  }
-  // biome-ignore lint/style/useNamingConvention: toJSON is a name to be used in JSON.stringify
-  toJSON() {
-    return this.#props;
-  }
-};
-var entity = (fields) => {
-  return class extends Entity {
-    constructor(props) {
-      super(props, fields);
-    }
-  };
 };
+function createEntity(fields, methodDefinitionFunction) {
+  return new EntityFactory(fields, methodDefinitionFunction);
+}
 export {
-  entity
+  createEntity
 };

package/dist/field.d.ts

@@ -24,7 +24,7 @@ type HasDefault<T extends ConfigurableFieldBase<unknown>> = T & {
 };
 export declare abstract class Field<T> implements ConfigurableFieldBase<T> {
     _: FieldConfig<T>;
-    protected config: FieldRuntimeConfig<T>;
+    config: FieldRuntimeConfig<T>;
     constructor();
     notRequired(): NotRequired<this>;
     default(value: T): HasDefault<this>;

package/dist/fields/entity.d.ts

@@ -0,0 +1,5 @@
+import { Field } from "../field.ts";
+declare class EntityField<T> extends Field<T> {
+}
+export declare const entity: <T>() => EntityField<T>;
+export {};

package/dist/fields/entity.js

@@ -0,0 +1,41 @@
+// src/field.ts
+var Field = class {
+  config;
+  constructor() {
+    this.config = {
+      notRequired: false,
+      hasDefault: false,
+      default: void 0
+    };
+  }
+  notRequired() {
+    this.config.notRequired = true;
+    return this;
+  }
+  default(value) {
+    this.config.default = value;
+    this.config.hasDefault = true;
+    return this;
+  }
+  defaultFn(fn) {
+    this.config.defaultFn = fn;
+    this.config.hasDefault = true;
+    return this;
+  }
+  getConfig() {
+    return this.config;
+  }
+  getDefaultValue() {
+    return this.config.default ?? this.config.defaultFn?.();
+  }
+};
+
+// src/fields/entity.ts
+var EntityField = class extends Field {
+};
+var entity = () => {
+  return new EntityField();
+};
+export {
+  entity
+};

package/dist/fields/index.d.ts

@@ -2,4 +2,5 @@ import { boolean } from "./boolean.ts";
 import { date } from "./date.ts";
 import { number } from "./number.ts";
 import { string } from "./string.ts";
-export { string, number, boolean, date };
+import { entity } from "./entity.ts";
+export { string, number, boolean, date, entity };

package/dist/fields/index.js

@@ -57,9 +57,17 @@ var StringField = class extends Field {
 var string = () => {
   return new StringField();
 };
+
+// src/fields/entity.ts
+var EntityField = class extends Field {
+};
+var entity = () => {
+  return new EntityField();
+};
 export {
   boolean,
   date,
+  entity,
   number,
   string
 };

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-import { entity } from "./entity.ts";
-import { boolean, date, number, string } from "./fields/index.ts";
-export { entity, string, number, boolean, date };
+import { createEntity } from "./entity.ts";
+import { boolean, date, number, string, entity } from "./fields/index.ts";
+export { createEntity, string, number, boolean, date, entity };

package/dist/index.js

@@ -1,52 +1,44 @@
 // src/entity.ts
-var Entity = class {
-  #entityConfig;
-  #props;
-  constructor(props, entityConfig) {
-    this.#entityConfig = entityConfig;
-    Object.freeze(this.#entityConfig);
-    this.#props = Object.entries(entityConfig).reduce(
+var EntityFactory = class {
+  fields;
+  methodDefinitionFunction;
+  constructor(fields, methodDefinitionFunction) {
+    this.fields = fields;
+    this.methodDefinitionFunction = methodDefinitionFunction;
+  }
+  create(props) {
+    const assignedProps = Object.entries(this.fields).reduce(
       (acc, [key, field]) => {
         const value = props[key] ?? field.getDefaultValue();
         if (field.getConfig().hasDefault && value === void 0) {
-          throw new Error(`The field "${key}" has a default value but undefined was provided.`);
+          acc[key] = field.getDefaultValue();
+        } else {
+          acc[key] = value;
         }
-        acc[key] = value;
         return acc;
       },
       {}
     );
+    const set = (key, value) => {
+      assignedProps[key] = value;
+    };
+    const get = (key) => {
+      return assignedProps[key];
+    };
+    const toJSON = () => {
+      return assignedProps;
+    };
+    const methods = this.methodDefinitionFunction?.({ set, get }) ?? {};
+    return {
+      get,
+      toJSON,
+      ...methods
+    };
   }
-  /**
-   * Get the value of the field by key
-   * @param key
-   */
-  get(key) {
-    return this.#props[key];
-  }
-  /**
-   * Set the value of the field by key
-   *
-   * WARNING: This method should be called only from the methods of the entity.
-   * Its accessor should be protected but TypeScript declaration does not allow protected methods in exported classes.
-   * @param key
-   * @param value
-   */
-  set(key, value) {
-    this.#props[key] = value;
-  }
-  // biome-ignore lint/style/useNamingConvention: toJSON is a name to be used in JSON.stringify
-  toJSON() {
-    return this.#props;
-  }
-};
-var entity = (fields) => {
-  return class extends Entity {
-    constructor(props) {
-      super(props, fields);
-    }
-  };
 };
+function createEntity(fields, methodDefinitionFunction) {
+  return new EntityFactory(fields, methodDefinitionFunction);
+}
 
 // src/field.ts
 var Field = class {
@@ -107,8 +99,16 @@ var StringField = class extends Field {
 var string = () => {
   return new StringField();
 };
+
+// src/fields/entity.ts
+var EntityField = class extends Field {
+};
+var entity = () => {
+  return new EntityField();
+};
 export {
   boolean,
+  createEntity,
   date,
   entity,
   number,

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "simplentity",
-  "version": "0.1.2",
+  "version": "1.0.0-alpha.1",
+  "description": "A type-safe entity library for TypeScript.",
   "type": "module",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",