@aurios/mizzle 1.0.0 → 1.1.0

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # mizzle
 
+## 2.0.0
+
+### Major Changes
+
+- 5dd0c9f: rename packages to @aurios scope
+
+### Patch Changes
+
+- 114efb9: Completed 100% JSDoc/TSDoc coverage for all public APIs and improved internal type safety.
+
+  - **@aurios/mizzle**: Added comprehensive documentation to Query Builders, Schema Definitions, and the main entry point. Resolved numerous linting issues by replacing `any` with safer alternatives.
+  - **@aurios/mizzling**: Fixed CLI entry point in E2E and integration tests, ensuring CI stability.
+  - **@mizzle/shared**: Enhanced utility type safety.
+  - **Infrastructure**: Updated Turbo configuration to handle new environment variables.
+
 ## 1.0.1
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aurios/mizzle",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "private": false,
   "description": "a drizzle-like orm for dynamoDB",
   "type": "module",

package/src/builders/base.ts

@@ -18,7 +18,7 @@ export abstract class BaseBuilder<
     }
 
     public get tableName(): string {
-        return resolveTableName(this.entity as any);
+        return resolveTableName(this.entity as unknown as Entity);
     }
 
     protected get physicalTable() {

package/src/builders/batch-get.ts

@@ -1,5 +1,5 @@
 import { BatchGetCommand } from "@aws-sdk/lib-dynamodb";
-import { ENTITY_SYMBOLS, TABLE_SYMBOLS } from "@mizzle/shared";
+import { ENTITY_SYMBOLS } from "@mizzle/shared";
 import { Entity, type InferSelectModel } from "../core/table";
 import { BaseBuilder } from "./base";
 import type { IMizzleClient } from "../core/client";
@@ -33,7 +33,7 @@ export class BatchGetBase<
 
     public override async execute(): Promise<BatchGetResult<TResult>> {
         const succeeded: TResult[] = [];
-        const failed: Record<string, unknown>[] = [];
+        const failed: Partial<TResult>[] = [];
 
         // Group keys by resolved DynamoDB keys
         let currentKeys = this.keysData.map(k => this.resolveKeys(undefined, k as Record<string, unknown>).keys);
@@ -52,7 +52,7 @@ export class BatchGetBase<
                 }
             });
 
-            const response = await this.client.send(command);
+            const response = await this.client.send(command) as { Responses?: Record<string, unknown[]>, UnprocessedKeys?: Record<string, { Keys?: Record<string, unknown>[] }> };
             
             if (response.Responses?.[this.tableName]) {
                 succeeded.push(...(response.Responses[this.tableName] as TResult[]));
@@ -61,16 +61,16 @@ export class BatchGetBase<
             const unprocessed = response.UnprocessedKeys?.[this.tableName]?.Keys;
             
             if (unprocessed && unprocessed.length > 0) {
-                currentKeys = unprocessed as Record<string, unknown>[];
+                currentKeys = unprocessed;
             } else {
                 currentKeys = [];
             }
         }
 
         if (currentKeys.length > 0) {
-            failed.push(...currentKeys);
+            failed.push(...(currentKeys as Partial<TResult>[]));
         }
 
-        return { succeeded, failed: failed as any[] };
+        return { succeeded, failed };
     }
 }

package/src/builders/batch-write.ts

@@ -1,5 +1,5 @@
 import { BatchWriteCommand } from "@aws-sdk/lib-dynamodb";
-import { ENTITY_SYMBOLS, TABLE_SYMBOLS } from "@mizzle/shared";
+import { ENTITY_SYMBOLS } from "@mizzle/shared";
 import { Entity, type InferInsertModel } from "../core/table";
 import { BaseBuilder } from "./base";
 import type { IMizzleClient } from "../core/client";
@@ -10,9 +10,9 @@ export type BatchWriteOperation<TEntity extends Entity> =
     | { type: "put", item: InferInsertModel<TEntity> }
     | { type: "delete", keys: Partial<InferInsertModel<TEntity>> };
 
-export interface BatchWriteResult<T> {
+export interface BatchWriteResult<_T> {
     succeededCount: number;
-    failed: any[]; // Operations that failed after all retries
+    failed: unknown[]; // Operations that failed after all retries
 }
 
 export class BatchWriteBuilder {
@@ -38,7 +38,7 @@ export class BatchWriteBase<
 
     public override async execute(): Promise<BatchWriteResult<InferInsertModel<TEntity>>> {
         let succeededCount = 0;
-        let failed: any[] = [];
+        let failed: unknown[] = [];
 
         const requests = this.ops.map(op => {
             if (op.type === "put") {
@@ -64,7 +64,7 @@ export class BatchWriteBase<
             }
         });
 
-        let currentRequests = [...requests];
+        let currentRequests: unknown[] = [...requests];
         let attempts = 0;
         const maxBatchAttempts = 5;
 
@@ -73,11 +73,12 @@ export class BatchWriteBase<
             
             const command = new BatchWriteCommand({
                 RequestItems: {
-                    [this.tableName]: currentRequests
+                    [this.tableName]: currentRequests as any[]
                 }
             });
 
-            const response = await this.client.send(command);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const response = await this.client.send(command) as { UnprocessedItems?: Record<string, any[]> };
             
             const unprocessed = response.UnprocessedItems?.[this.tableName] || [];
             succeededCount += (currentRequests.length - unprocessed.length);

package/src/builders/delete.ts

@@ -23,6 +23,11 @@ export class DeleteBuilder<
         this._keys = keys;
     }
 
+    /**
+     * Instructs Mizzle to return the deleted item after execution.
+     * 
+     * @returns The current builder instance.
+     */
     returning(): this {
         this._returnValues = "ALL_OLD";
         return this;
@@ -46,6 +51,11 @@ export class DeleteBuilder<
         return super.createExpressionContext(prefix);
     }
 
+    /**
+     * Executes the delete operation.
+     * 
+     * @returns A promise that resolves to the deleted item if `.returning()` was called, otherwise undefined.
+     */
     public override async execute(): Promise<TResult> {
         const resolution = this.resolveKeys(undefined, this._keys);
 

package/src/builders/insert.ts

@@ -16,11 +16,26 @@ export class InsertBuilder<TEntity extends Entity> {
         private client: IMizzleClient,
     ) {}
 
+    /**
+     * Sets the values to be inserted into the database.
+     * 
+     * @example
+     * ```ts
+     * await db.insert(users).values({ id: "1", name: "Alice" }).execute();
+     * ```
+     * 
+     * @param values The object containing the attributes to insert.
+     * @returns An InsertBase instance for further chaining.
+     */
     values(values: InferInsertModel<TEntity>): InsertBase<TEntity> {
         return new InsertBase(this.entity, this.client, values);
     }
 }
 
+interface MinimalPhysicalTable {
+    [TABLE_SYMBOLS.INDEXES]?: Record<string, { config: { pk: string; sk?: string } }>;
+}
+
 export class InsertBase<
     TEntity extends Entity,
     TResult = undefined,
@@ -42,6 +57,11 @@ export class InsertBase<
         return this.valuesData;
     }
 
+    /**
+     * Instructs Mizzle to return the inserted item after execution.
+     * 
+     * @returns The current builder instance with an updated result type.
+     */
     returning(): InsertBase<TEntity, InferInsertModel<TEntity>> {
         this.shouldReturnValues = true;
         return this as unknown as InsertBase<TEntity, InferInsertModel<TEntity>>;
@@ -56,13 +76,13 @@ export class InsertBase<
 
         // Also resolve GSI keys if they are defined in strategies but not in resolution.keys
         const strategies = this.entity[ENTITY_SYMBOLS.ENTITY_STRATEGY] as unknown as Record<string, { pk: KeyStrategy, sk?: KeyStrategy }>;
-        const physicalTable = this.entity[ENTITY_SYMBOLS.PHYSICAL_TABLE];
-        const indexes = (physicalTable as any)?.[TABLE_SYMBOLS.INDEXES] || {};
+        const physicalTable = this.entity[ENTITY_SYMBOLS.PHYSICAL_TABLE] as unknown as MinimalPhysicalTable;
+        const indexes = physicalTable?.[TABLE_SYMBOLS.INDEXES] || {};
 
         for (const [indexName, strategy] of Object.entries(strategies)) {
             if (indexName === "pk" || indexName === "sk") continue;
 
-            const indexBuilder = indexes[indexName] as { config: { pk: string; sk?: string } } | undefined;
+            const indexBuilder = indexes[indexName];
             if (indexBuilder) {
                 if (strategy.pk && indexBuilder.config.pk) {
                     const pkValue = this.resolveStrategyValue(strategy.pk, itemToSave);
@@ -78,6 +98,12 @@ export class InsertBase<
         return finalItem;
     }
 
+    /**
+     * Executes the insert operation.
+     * 
+     * @returns A promise that resolves to the inserted item if `.returning()` was called, otherwise undefined.
+     * @throws {ItemSizeExceededError} if the item exceeds 400KB.
+     */
     override async execute(): Promise<TResult> {
         const finalItem = this.buildItem();
 
@@ -138,7 +164,9 @@ export class InsertBase<
             }
 
             const finalValue = item[key];
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             item[key] = typeof (col as any).mapToDynamoValue === "function" 
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 ? (col as any).mapToDynamoValue(finalValue) 
                 : finalValue;
 

package/src/builders/select.ts

@@ -23,6 +23,17 @@ export class SelectBuilder<TSelection extends SelectedFields | undefined> {
         private fields?: TSelection,
     ) {}
 
+    /**
+     * Specifies the entity to select from.
+     * 
+     * @example
+     * ```ts
+     * const results = await db.select().from(users).execute();
+     * ```
+     * 
+     * @param entity The Mizzle entity (table) to query.
+     * @returns A SelectBase instance to further chain the query.
+     */
     from<TEntity extends Entity>(entity: TEntity) {
         return new SelectBase(entity, this.client, this.fields);
     }
@@ -50,36 +61,103 @@ export class SelectBase<
         super(entity, client);
     }
 
+    /**
+     * Adds a filter criteria to the query.
+     * 
+     * For DynamoDB, this will be used as a `KeyConditionExpression` if the 
+     * primary keys are provided, otherwise it will be used as a `FilterExpression`.
+     * 
+     * @example
+     * ```ts
+     * import { eq, and, gt } from "@aurios/mizzle";
+     * 
+     * const results = await db.select()
+     *   .from(users)
+     *   .where(and(eq(users.id, 1), gt(users.age, 18)))
+     *   .execute();
+     * ```
+     * 
+     * @param expression The expression to filter by.
+     * @returns The current builder instance for chaining.
+     */
     where(expression: Expression): this {
         this._whereClause = expression;
         return this;
     }
 
+    /**
+     * Limits the total number of items returned by the query.
+     * 
+     * @example
+     * ```ts
+     * const results = await db.select().from(users).limit(10).execute();
+     * ```
+     * 
+     * @param val The maximum number of items to return.
+     * @returns The current builder instance for chaining.
+     */
     limit(val: number): this {
         this._limitVal = val;
         return this;
     }
 
+    /**
+     * Sets the page size for the underlying DynamoDB requests. 
+     * Use this with `.iterator()` to control how many items are fetched in each network request.
+     * 
+     * @param val The number of items per page.
+     * @returns The current builder instance for chaining.
+     */
     pageSize(val: number): this {
         this._pageSizeVal = val;
         return this;
     }
 
+    /**
+     * Enables or disables consistent reads for this query.
+     * 
+     * @param enabled Whether consistent read is enabled. Defaults to true.
+     * @returns The current builder instance for chaining.
+     */
     consistentRead(enabled: boolean = true): this {
         this._consistentReadVal = enabled;
         return this;
     }
 
+    /**
+     * Specifies the sort order for the query (only applicable for `Query` operations).
+     * 
+     * @param forward If true (default), results are sorted in ascending order. If false, descending.
+     * @returns The current builder instance for chaining.
+     */
     sort(forward: boolean): this {
         this._sortForward = forward;
         return this;
     }
 
+    /**
+     * Forces the use of a specific Global Secondary Index (GSI) or Local Secondary Index (LSI).
+     * 
+     * @param name The name of the index to use.
+     * @returns The current builder instance for chaining.
+     */
     index(name: string): this {
         this._forcedIndexName = name;
         return this;
     }
 
+    /**
+     * Returns an async iterator that automatically handles pagination.
+     * 
+     * @example
+     * ```ts
+     * for await (const user of db.select().from(users).iterator()) {
+     *   console.log(user.name);
+     * }
+     * ```
+     * 
+     * @returns An AsyncIterableIterator for the query results.
+     */
     iterator(): AsyncIterableIterator<TResult> {
         const self = this;
         return (async function* () {
@@ -115,6 +193,12 @@ export class SelectBase<
         }
     }
 
+    /**
+     * Executes the query and returns all matching items.
+     * 
+     * @returns A promise that resolves to an array of items.
+     * @throws Error if the query fails.
+     */
     override async execute(): Promise<TResult[]> {
         const { items } = await this.fetchPage();
         return items;

package/src/builders/update.ts

@@ -32,16 +32,44 @@ export class UpdateBuilder<
         super(entity, client);
     }
 
+    /**
+     * Manually specifies the primary key for the update operation.
+     * 
+     * @param keyObject The raw DynamoDB key object (e.g., { pk: "USER#1", sk: "METADATA" }).
+     * @returns The current builder instance for chaining.
+     */
     key(keyObject: Record<string, unknown>): this {
         this._explicitKey = keyObject;
         return this;
     }
 
+    /**
+     * Sets specific attributes to new values. 
+     * Translates to a `SET` action in the DynamoDB UpdateExpression.
+     * 
+     * @example
+     * ```ts
+     * await db.update(users)
+     *   .set({ name: "Bob", age: 25 })
+     *   .where(eq(users.id, "1"))
+     *   .execute();
+     * ```
+     * 
+     * @param values Object containing the fields and values to set.
+     * @returns The current builder instance for chaining.
+     */
     set(values: Partial<{ [K in keyof InferInsertModel<TEntity>]: InferInsertModel<TEntity>[K] | UpdateAction }>): this {
         partitionUpdateValues(values as Record<string, any>, this._state, this.entity[ENTITY_SYMBOLS.COLUMNS] as Record<string, any>);
         return this;
     }
 
+    /**
+     * Adds a value to a numeric attribute or elements to a set.
+     * Translates to an `ADD` action in the DynamoDB UpdateExpression.
+     * 
+     * @param values Object containing fields and values to add.
+     * @returns The current builder instance for chaining.
+     */
     add(values: Partial<InferInsertModel<TEntity>>): this {
         const columns = this.entity[ENTITY_SYMBOLS.COLUMNS] as Record<string, any>;
         for (const [key, val] of Object.entries(values)) {
@@ -53,11 +81,25 @@ export class UpdateBuilder<
         return this;
     }
 
+    /**
+     * Removes one or more attributes from the item.
+     * Translates to a `REMOVE` action in the DynamoDB UpdateExpression.
+     * 
+     * @param fields The names of the fields to remove.
+     * @returns The current builder instance for chaining.
+     */
     remove(...fields: (keyof InferInsertModel<TEntity> | (string & {}))[]): this {
         this._state.remove.push(...(fields as string[]));
         return this;
     }
 
+    /**
+     * Deletes elements from a set.
+     * Translates to a `DELETE` action in the DynamoDB UpdateExpression.
+     * 
+     * @param values Object containing fields and the values to delete from the set.
+     * @returns The current builder instance for chaining.
+     */
     delete(values: Partial<InferInsertModel<TEntity>>): this {
         const columns = this.entity[ENTITY_SYMBOLS.COLUMNS] as Record<string, any>;
         for (const [key, val] of Object.entries(values)) {
@@ -69,11 +111,23 @@ export class UpdateBuilder<
         return this;
     }
 
+    /**
+     * Adds a condition to the update operation.
+     * 
+     * @param expression The condition expression.
+     * @returns The current builder instance for chaining.
+     */
     where(expression: Expression): this {
         this._whereClause = expression;
         return this;
     }
 
+    /**
+     * Configures what values should be returned after the update.
+     * 
+     * @param value One of: "NONE", "ALL_OLD", "UPDATED_OLD", "ALL_NEW", "UPDATED_NEW".
+     * @returns The current builder instance for chaining.
+     */
     returning(value: "NONE" | "ALL_OLD" | "UPDATED_OLD" | "ALL_NEW" | "UPDATED_NEW"): this {
         this._returnValues = value;
         return this;
@@ -94,6 +148,12 @@ export class UpdateBuilder<
         return super.createExpressionContext(prefix);
     }
 
+    /**
+     * Executes the update operation.
+     * 
+     * @returns A promise that resolves to the requested attributes (based on `.returning()`).
+     * @throws {ItemSizeExceededError} if the update exceeds 400KB.
+     */
     public override async execute(): Promise<TResult> {
         const columns = this.entity[ENTITY_SYMBOLS.COLUMNS] as Record<string, any>;
         for (const [key, col] of Object.entries(columns)) {

package/src/columns/binary-set.ts

@@ -1,7 +1,6 @@
 import {
     Column,
     type ColumnBaseConfig,
-    type ColumnRuntimeConfig,
 } from "../core/column";
 import {
     ColumnBuider,
@@ -30,6 +29,7 @@ export class BinarySetColumnBuilder<
     ): BinarySetColumn<MakeColumnConfig<T, TTableName>> {
         return new BinarySetColumn<MakeColumnConfig<T, TTableName>>(
             table,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             this.config as any,
         );
     }
@@ -44,6 +44,21 @@ export function binarySet(): BinarySetColumnInitial<"">;
 export function binarySet<TName extends string>(
     name: TName,
 ): BinarySetColumnInitial<TName>;
+/**
+ * Defines a Binary Set column ("BS") in DynamoDB.
+ * 
+ * Represents a set of unique binary blobs (Uint8Array/Buffer).
+ * 
+ * @example
+ * ```ts
+ * const data = defineTable("data", {
+ *   hashes: binarySet("hashes"),
+ * });
+ * ```
+ * 
+ * @param name The name of the attribute in DynamoDB. If omitted, it will use the property name in the definition object.
+ * @returns A BinarySetColumnBuilder instance.
+ */
 export function binarySet(name?: string) {
     return new BinarySetColumnBuilder(name ?? "");
 }

package/src/columns/binary.ts

@@ -1,7 +1,6 @@
 import {
     Column,
     type ColumnBaseConfig,
-    type ColumnRuntimeConfig,
 } from "../core/column";
 import {
     ColumnBuider,
@@ -29,6 +28,7 @@ export class BinaryColumnBuilder<
     ): BinaryColumn<MakeColumnConfig<T, TTableName>> {
         return new BinaryColumn<MakeColumnConfig<T, TTableName>>(
             table,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             this.config as any,
         );
     }
@@ -43,6 +43,22 @@ export function binary(): BinaryBuilderInitial<"">;
 export function binary<TName extends string>(
     name: TName,
 ): BinaryBuilderInitial<TName>;
+/**
+ * Defines a Binary column ("B") in DynamoDB.
+ * 
+ * Used for storing arbitrary binary data, such as images, compressed files, or raw bytes.
+ * Mizzle handles `Uint8Array` or `Buffer` (in Node) for this type.
+ * 
+ * @example
+ * ```ts
+ * const files = defineTable("files", {
+ *   content: binary("content"),
+ * });
+ * ```
+ * 
+ * @param name The name of the attribute in DynamoDB. If omitted, it will use the property name in the definition object.
+ * @returns A BinaryColumnBuilder instance.
+ */
 export function binary(name?: string) {
     return new BinaryColumnBuilder(name ?? "");
 }

package/src/columns/boolean.ts

@@ -2,7 +2,6 @@ import { Column, type ColumnBaseConfig } from "../core/column";
 import {
     ColumnBuider,
     type ColumnBuilderBaseConfig,
-    type ColumnBuilderRuntimeConfig,
     type MakeColumnConfig,
 } from "../core/column-builder";
 import type { AnyTable } from "../core/table";
@@ -26,6 +25,7 @@ export class BooleanColumnBuilder<
     ): BooleanColumn<MakeColumnConfig<T, TTableName>> {
         return new BooleanColumn<MakeColumnConfig<T, TTableName>>(
             table,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             this.config as any,
         );
     }
@@ -40,6 +40,19 @@ export function boolean(): BooleanColumnInitial<"">;
 export function boolean<TName extends string>(
     name: TName,
 ): BooleanColumnInitial<TName>;
+/**
+ * Defines a Boolean column ("BOOL") in DynamoDB.
+ * 
+ * @example
+ * ```ts
+ * const users = defineTable("users", {
+ *   isActive: boolean("is_active").default(true),
+ * });
+ * ```
+ * 
+ * @param name The name of the attribute in DynamoDB. If omitted, it will use the property name in the definition object.
+ * @returns A BooleanColumnBuilder instance.
+ */
 export function boolean(name?: string) {
     return new BooleanColumnBuilder(name ?? "");
 }

package/src/columns/date.ts

@@ -1,7 +1,6 @@
 import {
     Column,
     type ColumnBaseConfig,
-    type ColumnRuntimeConfig,
 } from "../core/column";
 import {
     ColumnBuider,
@@ -27,10 +26,12 @@ export class DateColumnBuilder<
     }
 
     defaultNow(): HasRuntimeDefault<HasDefault<this>> {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return this.$defaultFn(() => new Date() as any);
     }
 
     onUpdateNow(): HasDefault<this> {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return this.$onUpdateFn(() => new Date() as any);
     }
 
@@ -39,6 +40,7 @@ export class DateColumnBuilder<
     ): DateColumn<MakeColumnConfig<T, TTableName>> {
         return new DateColumn<MakeColumnConfig<T, TTableName>>(
             table,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             this.config as any,
         );
     }
@@ -78,6 +80,23 @@ export class DateColumn<
 
 export function date(): DateColumnInitial<"">;
 export function date<TName extends string>(name: TName): DateColumnInitial<TName>;
+/**
+ * Defines a Date column.
+ * 
+ * In DynamoDB, this is stored as an ISO 8601 string ("S"), but Mizzle automatically 
+ * handles conversion to/from JavaScript Date objects in your application code.
+ * 
+ * @example
+ * ```ts
+ * const posts = defineTable("posts", {
+ *   createdAt: date("created_at").defaultNow(),
+ *   updatedAt: date("updated_at").onUpdateNow(),
+ * });
+ * ```
+ * 
+ * @param name The name of the attribute in DynamoDB. If omitted, it will use the property name in the definition object.
+ * @returns A DateColumnBuilder instance.
+ */
 export function date(name?: string) {
     return new DateColumnBuilder(name ?? "");
 }

package/src/columns/json.ts

@@ -1,7 +1,6 @@
 import {
     Column,
     type ColumnBaseConfig,
-    type ColumnRuntimeConfig,
 } from "../core/column";
 import {
     ColumnBuider,
@@ -29,6 +28,7 @@ export class JsonColumnBuilder<
     ): JsonColumn<MakeColumnConfig<T, TTableName>> {
         return new JsonColumn<MakeColumnConfig<T, TTableName>>(
             table,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             this.config as any,
         );
     }
@@ -57,6 +57,29 @@ export function json(): JsonColumnInitial<"">;
 export function json<TName extends string>(
     name: TName,
 ): JsonColumnInitial<TName>;
+/**
+ * Defines a JSON column.
+ * 
+ * In DynamoDB, this is stored as a string ("S") containing serialized JSON.
+ * Mizzle automatically handles JSON.stringify/parse for you.
+ * 
+ * You can type the JSON object using the `.$type<T>()` method.
+ * 
+ * @example
+ * ```ts
+ * interface Address {
+ *   street: string;
+ *   city: string;
+ * }
+ * 
+ * const users = defineTable("users", {
+ *   address: json("address").$type<Address>(),
+ * });
+ * ```
+ * 
+ * @param name The name of the attribute in DynamoDB. If omitted, it will use the property name in the definition object.
+ * @returns A JsonColumnBuilder instance.
+ */
 export function json(name?: string) {
     return new JsonColumnBuilder(name ?? "");
 }