Unclear about Typescript usage

[filipeestacio]

I'm having a lot of trouble understanding how to use Typescript with ElectroDB. It's probably just lack of skill to understand the docs, but I could really benefit from an example, please.

For instance, in my application I have defined as Account Entity as such:

	model: {
		service: "app",
		entity: "account",
		version: "1.0.0",
	},
	attributes: {
		id: {
			type: "string",
			required: true,
			default: () => uuidv4(),
		},
		name: {
			type: "string",
			required: true,
		},
		type: {
			type: ["propertyowner", "serviceprovider", "utilitycompany"] as const,
			required: true,
		},
		createdAt: {
			type: "string",
			required: true,
			default: () => new Date().toISOString(),
		},
		updatedAt: {
			type: "string",
			required: true,
			default: () => new Date().toISOString(),
		},
		deletedAt: {
			type: "string",
		},
	},
	indexes: {
		accounts: {
			collection: "membership",
			pk: {
				field: "pk",
				composite: ["id"],
			},
			sk: {
				field: "sk",
				composite: [],
			},
		},
	},
});

const AccountEntity = new Entity(AccountSchema, {
	client,
	table: constants.TABLE_APP,
});

export default AccountEntity;

And I am using this Entity here:

import AccountEntity from "../entities/Account";

const AccountsService = {
	create: async (account) => {
		const result = await AccountEntity.create(account).go();
		if (!result) {
			throw new Error("Failed to create account");
		}
		return result.data;
	},

	get: async (id) => AccountEntity.get({ id }).go(),
};

export default AccountsService;

How do I add the correct type annotations to the create and the get method? I've tried a bunch of things, but at this point I'm not even throwing educated guesses anymore so would really appreciate some pointing in the right direction. I feel like there is a paragraph missing from the docs or something.

[filipeestacio]

Wait. I think I got it. Does this look about right?

import type {
	CreateEntityItem,
	EntityIdentifiers,
	EntityItem,
} from "electrodb";
import Account from "../entities/Account";

export type AccountKeys = EntityIdentifiers<typeof Account>;
export type AccountCreateItem = CreateEntityItem<typeof Account>;
export type AccountItem = EntityItem<typeof Account>;

const AccountsService = {
	create: async (
		accountCreateItem: AccountCreateItem,
	): Promise<AccountItem> => {
		try {
			const { data } = await Account.create(accountCreateItem).go({});
			return data;
		} catch (error) {
			throw new Error(
				`Error creating account: ${error instanceof Error ? error.message : "Unknown error"}`,
			);
		}
	},

	get: async (accountKeys: AccountKeys): Promise<AccountItem> => {
		try {
			const { data } = await Account.get(accountKeys).go();
			return data;
		} catch (error) {
			throw new Error(
				`Error getting account: ${error instanceof Error ? error.message : "Unknown error"}`,
			);
		}
	},
};

export default AccountsService;

[filipeestacio]

Thank you, @tywalch! I did stumble onto another one! Sorry for the hassle.

One of my entities has a number of properties which have required: false. However, when I use type NewThing = CreateEntityItem<typeof MyEntityInstance>;, I get all the properties of the entity as mandatory in the type, regardless of the value of required. Is this expected? Is there a way around it?

[tywalch]

It is difficult to say without seeing your schema, though if any of those attributes are involved in the Primary Index, then they would be required no matter what.

[filipeestacio]

This is the schema I built for this entity. Please let me know if it would be more helpful to write it in the Playground!

I think there is something related to the strict mode. I'm saying this because I am not enforcing strict mode in my tsconfig in this package and the unit tests allow me to instantiate a CreateEntityItem with only a userId and Email.

I am importing this package into another project that is enforcing strict mode and on that one I have typescript shouting at for not including firstName, lastName, accountName, etc.

import { Entity, type Schema, createSchema } from "electrodb";
import client from "../clients/dynamodb";
import { TABLE_APP } from "../constants";

const schema = createSchema({
	model: {
		service: "app",
		entity: "onboarding",
		version: "1.0.0",
	},
	attributes: {
		userId: {
			type: "string",
			required: true as boolean,
		},
		email: {
			type: "string",
			required: true as boolean,
		},
		firstName: {
			type: "string",
			required: false as boolean,
		},
		lastName: {
			type: "string",
			required: false as boolean,
		},
		accountType: {
			type: "string",
			required: false as boolean,
		},
		accountName: {
			type: "string",
			required: false as boolean,
		},
		created: {
			type: "map",
			required: true as boolean,
			properties: {
				at: {
					type: "string",
					required: true as boolean,
					default: () => new Date().toISOString(),
				},
				by: {
					type: "string",
					required: true as boolean,
					default: "system",
				},
			},
			default: () => ({
				at: new Date().toISOString(),
				by: "system",
			}),
		},
		updated: {
			type: "map",
			required: true as boolean,
			properties: {
				at: {
					type: "string",
					required: true as boolean,
					default: () => new Date().toISOString(),
				},
				by: {
					type: "string",
					required: true as boolean,
					default: "system",
				},
			},
			default: () => ({
				at: new Date().toISOString(),
				by: "system",
			}),
		},
	},
	indexes: {
		session: {
			pk: {
				field: "pk",
				composite: ["userId"],
			},
			sk: {
				field: "sk",
				composite: [],
			},
		},
	},
});

const entity = new Entity(schema, {
	client,
	table: TABLE_APP,
});

export default entity;

[tywalch]

I see you're casting the readOnly values to Booleans (as boolean); that is likely why you're seeing this behavior, is that choice for some other purpose?

[filipeestacio]

That was me actually going the other direction, trying to test if casting the required fields would help. I've removed the casts, but still seeing the same behaviour.

One thing I am noticing is that the created.at, created.by, updated.at, and updated.by are optional because they have defaults.