(λ) Function Oriented Programming (FOP)

// Which functions are pure and which are not

const fn1 = (a: string): string => {
	return a + ", hi!"
}

const fn2 = (a: { name: string }) => {
	a.name += ", hi!"
	return a
}

const fn3 = (a: { name: string }) => {
	fn2(a)

	return a.name + ", hi!"
}

const fn4 = (a: { name: string }) => {
	return {
		name: a.name + ", hi!"
	}
}

const fn5 = (a: { name: string }) => {
	const newName = fn4(a)

	newName.name += " Bye!"

	reutrn newName
}

let counter = 0
const fn6 = () => {
	counter += 1
	return `Updated ${counter} times`
}


const fn7 = () => {
	let counter = 0
	return () => {
		counter += 1
		return `Updated ${counter} times`
	}
}

const fn8 = (a: number): number => {
	console.log(Math.random())
	return a * 2
}

const fn9 = (
	db: {update: (byId: string, email: string) => void},
	id: string,
	newEmail: srtring
) => {
	return db.update(id, newEmail)
}

const fn10 = (db: {getById: (id: string) => User}, id: string) => {
	return db.getById(id)
}

// Pure
const fn1 = (a: string): string => {
	return a + ", hi!"
}

// Not pure, because it changes external state (argument)
const fn2 = (a: { name: string }): { name: string } => {
	a.name += ", h1!"
	return a
}

// Not pure, because it uses another impure function (fn2)
const fn3 = (a: { name: string }) => {
	fn2(a)

	return a.name + ", hi!"
}

// Pure, because it doesn't change anything
const fn4 = (a: { name: string }) => {
	return {
		name: a.name + ", hi!"
	}
}

// Not pure, because it changes the return value of an internal pure function (fn4)
const fn5 = (a: { name: string }) => {
	const newName = fn4(a)

	newName.name += " Bye!"

	reutrn newName
}

// Not pure, because it changes external state (external variable)
let counter = 0
const fn6 = () => {
	counter += 1
	return `Updated ${counter} times`
}

// This can be called pure
const fn7 = () => {
	let counter = 0
	// But this is an impure function because it changes external state (external variable)
	return () => {
		counter += 1
		return `Updated ${counter} times`
	}
}

// Not pure, because it creates 2 side effects:
// 1. console.log - this changes external state (stdout.write)
// 2. Math.random() - this is a side effect because it accesses the OS to get a seed for randomness
const fn8 = (a: number): number => {
	console.log(Math.random())
	return a * 2
}

// Not pure, because it creates 2 side effects:
// 1. It accesses an external system (db)
// 2. It changes state (db.update)
const fn9 = (
	db: {update: (byId: string, email: string) => void},
	id: string,
	newEmail: srtring
) => {
	return db.update(id, newEmail)
}

// Not pure, because it creates a side effect: it accesses an external system (db)
const fn10 = (db: {getById: (id: string) => User}, id: string) => {
	return db.getById(id)
}

1. What if we need to access external systems (db)?

2. What if we still need to change something?

// Types
type User = {
	id: string
	email: string
	// password: string - this field exists in the DB, but we don't want to retrieve it into the program
}

type DB = {
	updateById: (id: string, user: User) => void
	getById: (id: string) => User
}

// Impure function for working with the database
const updateUser = (
	db: db,
	user: User,
) => {
	return db.updateById(user.id, user)
}

// Impure function for working with the database
const getUserById = (db: DB, id: string) => {
	const res = db.getById(id)

	return {
		id: res.id,
		email: res.email
	}
}

// Pure function for business logic
const assignNewUserEmail = (user: User, newEmail: string) => {
	if (!newEmail.includes("@") {
		throw new Error(`Email is invalid`)
	}

	if (user.email === newEmail) {
		throw new Error(`New email must be different`)
	}

	return {
		...user,
		email: newEmail,
	}
}

// Now we combine them
const updateUserEmailController = (db: DB, userId: string, newEmail: string) => {
	const user = getUserById(db, userId)
	
	const updatedUser = assignNewUserEmail(user, newEmail)

	updateUser(db, updatedUser)
}

type User = {
	firstName: string;
	secondName: string;
	fio: string | undefined;
}

const addFIO = (user: User): User => {
	return {
		...user, // Copy all properties
		fio: user.firstName + user.secondName // add a new field
	}
}

const someFn = (someArray: string[]) => {
	const array = []

	for (let i = 0; i < someArray.length; i++) {
		// We can modify array because it was created in this same function
		array.push(someArray[i] + ", hi!")
	}

	return array
}

const predictabilityExample = async (db: DB) => {
	const user = await db.getUser()
	const userSubscriptions = await db.getUserSubscriptions(user.id)
	const userWallet = await db.getUserWallet(user.id)
	
	await changeUserSubscriptionPlan(user, userSubscriptions, userWallet)
}

const predictabilityExample = async (db: DB) => {
	const user = await db.getUser()
	const userSubscriptions = await db.getUserSubscriptions(user.id)
	const userWallet = await db.getUserWallet(user.id)
	
	const [updatedUserSubscriptions, updatedUserWallet] = await changeUserSubscriptionPlan(user, userSubscriptions, userWallet)
}

type User = {
	id: string
	username: string
	team: {
		id: string
		name: string
		members: User[]
	}
}

const shallowComparisonExample = async (db: DB) => {
	const user: User = await db.getUser()
	const updatedUser = await someFunctionThatUpdateSomethingInUser(user)
	if (user !== updatedUser) {
		// It doesn't matter what changed and how deeply in user, if
		// any change occurred, user and updatedUser will have
		// different references
	}
}

type User = {
	id: string
	username: string
	team: {
		id: string
		name: string
		members: User[]
	}
}


// Very simplified function for checking changes
const compare = (recordA: Record<any, any>, recordB: Record<any, any>) => {
	// Iterate through Record properties
	for (const property in recordB) {
	  if (recordA[property] !== recordB[property]) {
			console.log(`Property ${property} changed from ${recordA[property]} to ${recordB[property]}`)
			// Simplified check if the field is also an object
			if (typeof recordB[property] === 'object') {
				compare(recordA[property], recordB[property])
			}
		}
	}
}

const shallowComparisonExample = async (db: DB) => {
	const user: User = await db.getUser()
	const updatedUser = someFunctionThatUpdateSomethingInUser(user)
	if (user !== updatedUser) {
		compare(user, updatedUser)
	}
}

const UserDataService = (db: DB) => {
	let users = {}
	return {
		getUserById: (id: string): User => {
			const user = await db.getUser({id: id})
			users = {
				...users,
				[user.id]: user,
			}
		},
		saveUser: (updatedUser: User): Promise<User> => {
			// The getChangedPropertiesAndValues function returns an object only with changed
			// fields and their values. It works very quickly because I know that my code
			// is immutable, which means that if the user has changed at all, it's enough to make a simple check
			const delta = getChangedPropertiesAndValues(updatedUser, users[updatedUser.id])
			if (delta) {
				await db.saveUser(delta)
			}
			return updatedUser
		}
	}
}

const uowExample = async (db: DB, userId: string) => {
	const userDS = UserDataService(db)
	const user: User = await userDS.getUserById(userId)
	const updatedUser = someFunctionThatUpdateSomethingInUser(user)
	await userDS.saveUser(updatedUser)
}

const raceConditionCounter = async () => {
	let counter = {
		value: 1
	}
	
	await Promise.all([
		async () => counter.value = counter.value - 1,
		async () => counter.value = counter.value * 4,
		async () => {
			if (counter.value === 0) throw new Error() 
			counter.value = counter.value / 2
		},
	])
	
	console.log(counter.value)
}

const raceConditionCounter = async () => {
	let counter = {
		value: 1
	}
	
	const [decrementedCounter, mulipliedCounter, dividedCounter] = await Promise.all([
		async () => { value: counter.value - 1 },
		async () => { value: counter.value * 4 },
		async () => {
			if (counter.value === 0) throw new Error() 
			return { value: counter.value / 2 },
		},
	])
	
	console.log(counter.value, decrementedCounter.value, mulipliedCounter.value, dividedCounter.value) // 1, 0, 4, 0.5
}

const user = getUser()
const userUpdatedEmail = updateUserEmail(user)
const userUpdatedEmailAndAge = updateUserAge(userUpdatedEmail)
const userUpdatedEmailAgeAddedRewards = addRewards(userUpdatedEmailAndAge)
const userToSave = updateUserAge(userUpdatedEmailAgeAddedRewards)
saveUser(userToSave)

// Soon such an operator will appear in JS,
// but it exists in functional languages like Elixir
const user = getUser(userId)
                         |-> updateUserEmail
                         |-> updateUserAge
                         |-> addRewards
                         |-> updateUserAge
                         |-> saveUser		

// An alternative could be composition
const user = saveUser(
	updateUserAge(
		addRewards(
			updateUserAge(
				updateUserEmail(
					getUser(userId)
				)
			)
		)
	)
)

// Or using third-party libraries, BUT I'll say right away,
// in TS for example, such functions are very difficult to type
// if they use generics
const user = pipe(
	getUser,
	updateUserEmail,
	updateUserAge,
	addRewards,
	updateUserAge,
	saveUser,
)(userId)