@axium/contacts 0.0.1

package/dist/common.js

@@ -0,0 +1,114 @@
+import { Location, serverConfigs } from '@axium/core';
+import { $API } from '@axium/core/api';
+import { zKeys } from '@axium/core/locales';
+import * as z from 'zod';
+const SmallText = z.string().nonempty().max(100);
+const LabelRequired = SmallText.clone().register(zKeys, { key: 'contact.label' });
+const Label = SmallText.nullish().register(zKeys, { key: 'contact.label' });
+const IsDefault = z.boolean().default(false).register(zKeys, { key: 'contact.default' });
+const Day = z.coerce.number().int().min(1).max(31);
+const Month = z.coerce.number().int().min(1).max(12);
+const Year = z.coerce.number().int().min(1).max(9999).nullish();
+const DatePartNull = z.coerce
+    .number()
+    .int()
+    .min(0)
+    .max(0)
+    .transform(() => null);
+export const ContactURL = z.url().max(100);
+export const Email = z.object({
+    email: z.email().max(255).register(zKeys, { key: 'contact.email' }),
+    label: Label,
+    isDefault: IsDefault,
+});
+export const Address = Location.extend({
+    label: Label,
+    isDefault: IsDefault,
+});
+export const Phone = z.object({
+    country: z.int().min(0).max(999).nullish(),
+    number: z.coerce
+        .bigint()
+        // @todo check length based on country code
+        .refine(val => val > 0n && val.toString().length)
+        .register(zKeys, { key: 'contact.phone.number' }),
+    label: Label,
+    isDefault: IsDefault,
+});
+export const SigDate = z.object({
+    year: Year,
+    month: Month,
+    day: Day,
+    label: Label,
+});
+export const Relationship = z.object({
+    to: z.uuid().register(zKeys, { key: 'contact.relationship.to' }),
+    label: LabelRequired,
+});
+export const Custom = z.object({
+    label: Label,
+    value: z.string().max(255).register(zKeys, { key: 'contact.custom.value' }),
+});
+export const Init = z.object({
+    display: SmallText.nullish().register(zKeys, { key: 'contact.display' }),
+    prefix: SmallText.nullish().register(zKeys, { key: 'contact.prefix' }),
+    givenName: SmallText.nullish().register(zKeys, { key: 'contact.given_name' }),
+    givenName2: SmallText.nullish().register(zKeys, { key: 'contact.given_name_2' }),
+    surname: SmallText.nullish().register(zKeys, { key: 'contact.surname' }),
+    suffix: SmallText.nullish().register(zKeys, { key: 'contact.suffix' }),
+    nickname: SmallText.nullish().register(zKeys, { key: 'contact.nickname' }),
+    company: SmallText.nullish().register(zKeys, { key: 'contact.company' }),
+    jobTitle: SmallText.nullish().register(zKeys, { key: 'contact.job_title' }),
+    department: SmallText.nullish().register(zKeys, { key: 'contact.department' }),
+    notes: z.string().max(1000).nullish().register(zKeys, { key: 'contact.notes' }),
+    birthDay: Day.or(DatePartNull).nullish(),
+    birthMonth: Month.or(DatePartNull).nullish(),
+    birthYear: Year.or(DatePartNull),
+    urls: ContactURL.array().max(100).default([]),
+    emails: Email.array().max(100).default([]),
+    addresses: Address.array().max(100).default([]),
+    phones: Phone.array().max(100).default([]),
+    dates: SigDate.array().max(100).default([]),
+    relationships: Relationship.array().max(100).default([]),
+    custom: Custom.array().max(100).default([]),
+    linkedUserId: z.uuid().nullish(),
+});
+export const Contact = Init.extend({
+    id: z.uuid(),
+    userId: z.uuid(),
+    createdAt: z.coerce.date(),
+    updatedAt: z.coerce.date(),
+});
+const _externalFields = {
+    addresses: true,
+    emails: true,
+    phones: true,
+    dates: true,
+    relationships: true,
+    custom: true,
+};
+/**
+ * Large contact fields, which are stored externally
+ */
+export const OnlyExternal = Contact.pick(_externalFields);
+export const InitNoExternal = Init.omit(_externalFields);
+export const NoExternal = Contact.omit(_externalFields);
+const ContactsConfig = z.object({
+    auto_link: z.boolean(),
+});
+serverConfigs.set('@axium/contacts', ContactsConfig);
+const ContactsAPI = {
+    'users/:id/contacts': {
+        GET: Contact.array(),
+        PUT: [Init, Contact],
+    },
+    'contact-discovery': {
+        POST: [z.string(), NoExternal.array()],
+    },
+    'contacts/:id': {
+        GET: Contact,
+        PATCH: [Init, Contact],
+        DELETE: Contact,
+    },
+};
+Object.assign($API, ContactsAPI);

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './common.js';

package/dist/index.js

@@ -0,0 +1 @@
+export * from './common.js';

package/dist/server/api.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server/api.js

@@ -0,0 +1,138 @@
+import { checkAuthForUser, requireSession } from '@axium/server/auth';
+import { database } from '@axium/server/database';
+import { parseBody, withError } from '@axium/server/requests';
+import { addRoute } from '@axium/server/routes';
+import * as z from 'zod';
+import * as contact from '../common.js';
+import { contactsFields, insertContactFields, tryAutoLink } from './db.js';
+function splitInit(init) {
+    const { addresses, emails, phones, dates, relationships, custom, ...rest } = init;
+    return [rest, { addresses, emails, phones, dates, relationships, custom }];
+}
+addRoute({
+    path: '/api/users/:id/contacts',
+    params: { id: z.uuid() },
+    async GET(request, { id: userId }) {
+        await checkAuthForUser(request, userId);
+        return await database.selectFrom('contacts').selectAll().select(contactsFields).where('userId', '=', userId).execute();
+    },
+    async PUT(request, { id: userId }) {
+        const init = await parseBody(request, contact.Init);
+        await checkAuthForUser(request, userId);
+        await tryAutoLink(init);
+        const [contactInit, fieldsInit] = splitInit(init);
+        const tx = await database.startTransaction().execute();
+        try {
+            const contact = await tx
+                .insertInto('contacts')
+                .values({ ...contactInit, userId })
+                .returningAll()
+                .executeTakeFirstOrThrow();
+            const rest = await insertContactFields(tx, contact.id, fieldsInit);
+            await tx.commit().execute();
+            return Object.assign(contact, rest);
+        }
+        catch (e) {
+            await tx.rollback().execute();
+            throw e;
+        }
+    },
+});
+addRoute({
+    path: '/api/contacts/:id',
+    params: { id: z.uuid() },
+    async GET(request, { id }) {
+        const contact = await database
+            .selectFrom('contacts')
+            .selectAll()
+            .select(contactsFields)
+            .where('id', '=', id)
+            .executeTakeFirstOrThrow()
+            .catch(withError('Contact does not exist', 404));
+        await checkAuthForUser(request, contact.userId);
+        return contact;
+    },
+    async PATCH(request, { id }) {
+        const init = await parseBody(request, contact.Init);
+        const { userId } = await database
+            .selectFrom('contacts')
+            .select('userId')
+            .where('id', '=', id)
+            .executeTakeFirstOrThrow()
+            .catch(withError('Contact does not exist', 404));
+        await checkAuthForUser(request, userId);
+        await tryAutoLink(init);
+        const [contactInit, fieldsInit] = splitInit(init);
+        const tx = await database.startTransaction().execute();
+        try {
+            const contact = await database
+                .updateTable('contacts')
+                .set({ ...contactInit, updatedAt: new Date() })
+                .where('id', '=', id)
+                .returningAll()
+                .executeTakeFirstOrThrow();
+            await Promise.all([
+                tx.deleteFrom('contact_addresses').where('id', '=', id).execute(),
+                tx.deleteFrom('contact_emails').where('id', '=', id).execute(),
+                tx.deleteFrom('contact_phones').where('id', '=', id).execute(),
+                tx.deleteFrom('contact_dates').where('id', '=', id).execute(),
+                tx.deleteFrom('contact_relationships').where('id', '=', id).execute(),
+                tx.deleteFrom('contact_custom').where('id', '=', id).execute(),
+            ]);
+            const rest = await insertContactFields(tx, contact.id, fieldsInit);
+            await tx.commit().execute();
+            return Object.assign(contact, rest);
+        }
+        catch (e) {
+            await tx.rollback().execute();
+            throw e;
+        }
+    },
+    async DELETE(request, { id }) {
+        const { userId } = await database
+            .selectFrom('contacts')
+            .select('userId')
+            .where('id', '=', id)
+            .executeTakeFirstOrThrow()
+            .catch(withError('Contact does not exist', 404));
+        await checkAuthForUser(request, userId);
+        return await database
+            .deleteFrom('contacts')
+            .where('id', '=', id)
+            .returningAll()
+            .returning(contactsFields)
+            .executeTakeFirstOrThrow();
+    },
+});
+addRoute({
+    path: '/api/contact-discovery',
+    async POST(request) {
+        const query = await parseBody(request, z.string().max(100));
+        const { userId } = await requireSession(request);
+        return await database
+            .selectFrom('contacts')
+            .selectAll()
+            .where('userId', '=', userId)
+            .where(eb => eb.or([
+            eb(eb.fn('concat_ws', [eb.val(' '), 'givenName', 'givenName2', 'surname']), 'like', `%${query}%`),
+            eb('id', 'in', eb.selectFrom('contact_emails').select('id').where('email', 'like', `%${query}%`)),
+            eb('id', 'in', eb
+                .selectFrom('contact_phones')
+                .select('id')
+                .where(eb => eb.cast('number', 'text'), 'like', `%${query}%`)),
+            eb('id', 'in', eb
+                .selectFrom('contact_addresses')
+                .select('id')
+                .where(eb => eb.fn('concat_ws', [
+                eb.val(' '),
+                'street1',
+                'street2',
+                'locality',
+                'subdivision',
+                'postalCode',
+                'country',
+            ]), 'like', `%${query}%`)),
+        ]))
+            .execute();
+    },
+});

package/dist/server/db.d.ts

@@ -0,0 +1,21 @@
+import { type Country } from '@axium/core';
+import { type Schema as DB } from '@axium/server/database';
+import type { FromFile as FromSchemaFile } from '@axium/server/db/schema';
+import type { AliasedRawBuilder, ControlledTransaction, ExpressionBuilder } from 'kysely';
+import type schema from '../../db.json';
+import * as contact from '../common.js';
+declare module '@axium/server/database' {
+    interface _DB extends FromSchemaFile<typeof schema> {
+    }
+    interface Schema extends _DB {
+        contact_addresses: _DB['contact_addresses'] & {
+            country: Country;
+        };
+    }
+}
+export declare function contactsFields(eb: ExpressionBuilder<DB, 'contacts'>): readonly [AliasedRawBuilder<contact.Address[], "addresses">, AliasedRawBuilder<contact.Email[], "emails">, AliasedRawBuilder<contact.Phone[], "phones">, AliasedRawBuilder<contact.SigDate[], "dates">, AliasedRawBuilder<contact.Relationship[], "relationships">, AliasedRawBuilder<contact.Custom[], "custom">];
+/**
+ * Try to automatically link the contact to a user
+ */
+export declare function tryAutoLink(init: contact.Init): Promise<void>;
+export declare function insertContactFields(tx: ControlledTransaction<DB, []>, id: string, init: contact.OnlyExternal): Promise<contact.OnlyExternal>;

package/dist/server/db.js

@@ -0,0 +1,75 @@
+import { getConfig } from '@axium/core';
+import { database } from '@axium/server/database';
+import { error } from '@axium/server/requests';
+import { jsonArrayFrom } from 'kysely/helpers/postgres';
+import * as contact from '../common.js';
+export function contactsFields(eb) {
+    function select(field) {
+        return jsonArrayFrom(eb
+            .selectFrom(`contact_${field}`)
+            // @ts-expect-error 2349
+            .select(Object.keys(fieldSchemas[field].shape))
+            .whereRef('id', '=', 'contacts.id'))
+            .$castTo()
+            .as(field);
+    }
+    return [select('addresses'), select('emails'), select('phones'), select('dates'), select('relationships'), select('custom')];
+}
+/**
+ * Try to automatically link the contact to a user
+ */
+export async function tryAutoLink(init) {
+    if (!getConfig('@axium/contacts').auto_link || init.linkedUserId || !init.emails.length)
+        return;
+    const emails = init.emails.map(e => e.email);
+    const user = await database.selectFrom('users').select('id').where('email', 'in', emails).executeTakeFirst();
+    if (!user)
+        return;
+    init.linkedUserId = user.id;
+}
+const fieldSchemas = {
+    addresses: contact.Address,
+    emails: contact.Email,
+    phones: contact.Phone,
+    dates: contact.SigDate,
+    relationships: contact.Relationship,
+    custom: contact.Custom,
+};
+export async function insertContactFields(tx, id, init) {
+    for (const [name, data] of [
+        ['addresses', init.addresses],
+        ['emails', init.emails],
+        ['phones', init.phones],
+    ]) {
+        let defaultItem;
+        for (const item of data) {
+            if (!item.isDefault)
+                continue;
+            if (defaultItem)
+                error(400, 'Can not have multiple default ' + name);
+            defaultItem = item;
+        }
+        if (!defaultItem && data.length)
+            data[0].isDefault = true;
+    }
+    async function insertWithId(field) {
+        const value = init[field];
+        if (!value.length)
+            return { [field]: [] };
+        const result = (await tx
+            .insertInto(`contact_${field}`)
+            .values(value.map(item => ({ ...item, id })))
+            .returning(Object.keys(fieldSchemas[field].shape))
+            .execute());
+        return { [field]: result };
+    }
+    const result = await Promise.all([
+        insertWithId('addresses'),
+        insertWithId('emails'),
+        insertWithId('phones'),
+        insertWithId('dates'),
+        insertWithId('relationships'),
+        insertWithId('custom'),
+    ]);
+    return Object.assign(...result);
+}

package/dist/server/hooks.d.ts

@@ -0,0 +1,4 @@
+import '../common.js';
+import './api.js';
+import './pfp.js';
+export declare function statusText(): Promise<string>;

package/dist/server/hooks.js

@@ -0,0 +1,8 @@
+import { count } from '@axium/server/database';
+import '../common.js';
+import './api.js';
+import './pfp.js';
+export async function statusText() {
+    const { contacts } = await count('contacts');
+    return `${contacts} contacts`;
+}

package/dist/server/index.d.ts

@@ -0,0 +1 @@
+export * from './db.js';

package/dist/server/index.js

@@ -0,0 +1 @@
+export * from './db.js';

package/dist/server/pfp.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server/pfp.js

@@ -0,0 +1,81 @@
+import { checkImageUpload } from '@axium/server/api/images';
+import { checkAuthForUser } from '@axium/server/auth';
+import { database } from '@axium/server/database';
+import { error, withError } from '@axium/server/requests';
+import { addRoute } from '@axium/server/routes';
+import { sql } from 'kysely';
+import * as z from 'zod';
+addRoute({
+    path: '/raw/contacts/pfp/:id',
+    params: { id: z.uuid() },
+    async HEAD(request, { id }) {
+        const { userId } = await database
+            .selectFrom('contacts')
+            .select('userId')
+            .where('id', '=', id)
+            .executeTakeFirstOrThrow()
+            .catch(withError('Contact does not exist', 404));
+        await checkAuthForUser(request, userId);
+        const pfp = await database.selectFrom('contact_pictures').selectAll().where('contactId', '=', id).executeTakeFirst();
+        if (!pfp)
+            error(404, 'Contact picture not found');
+        return new Response(null, {
+            headers: {
+                'content-type': pfp.type,
+                'content-length': pfp.data.length.toString(),
+            },
+        });
+    },
+    async GET(request, { id }) {
+        const { userId } = await database
+            .selectFrom('contacts')
+            .select('userId')
+            .where('id', '=', id)
+            .executeTakeFirstOrThrow()
+            .catch(withError('Contact does not exist', 404));
+        const pfp = await database.selectFrom('contact_pictures').selectAll().where('contactId', '=', id).executeTakeFirst();
+        if (!pfp)
+            error(404, 'Contact picture not found');
+        await checkAuthForUser(request, userId);
+        return new Response(pfp.data, {
+            headers: {
+                'content-type': pfp.type,
+                'content-length': pfp.data.length.toString(),
+            },
+        });
+    },
+    async POST(request, { id }) {
+        const { userId } = await database
+            .selectFrom('contacts')
+            .select('userId')
+            .where('id', '=', id)
+            .executeTakeFirstOrThrow()
+            .catch(withError('Contact does not exist', 404));
+        const { data, type } = await checkImageUpload(request, { enabled: true, max_size: 500, max_length: 1000 }, userId);
+        const { isInsert } = await database
+            .insertInto('contact_pictures')
+            .values({ contactId: id, data, type })
+            .onConflict(oc => oc.column('contactId').doUpdateSet({ data, type }))
+            .returning(sql `xmax = 0`.as('isInsert'))
+            .executeTakeFirstOrThrow()
+            .catch(withError('Failed to upload contact picture', 500));
+        return new Response(null, { status: isInsert ? 201 : 200 });
+    },
+    async DELETE(request, { id }) {
+        const { userId } = await database
+            .selectFrom('contacts')
+            .select('userId')
+            .where('id', '=', id)
+            .executeTakeFirstOrThrow()
+            .catch(withError('Contact does not exist', 404));
+        await checkAuthForUser(request, userId);
+        const result = await database
+            .deleteFrom('contact_pictures')
+            .where('contactId', '=', id)
+            .executeTakeFirst()
+            .catch(withError('Failed to delete contact picture', 500));
+        if (!result?.numDeletedRows)
+            error(404, 'Contact picture not found');
+        return new Response(null, { status: 204 });
+    },
+});

package/lib/ContactCard.svelte

@@ -0,0 +1,21 @@
+<script lang="ts">
+	import type { NoExternal } from '@axium/contacts';
+	import { format } from '@axium/contacts/client';
+
+	const { contact, compact }: { contact: NoExternal; compact?: boolean } = $props();
+
+	const name = format.name(contact);
+</script>
+
+<a href="/contacts/{contact.id}">{name}</a>
+
+<!-- @todo show expanded card on hover
+	<div class="ContactCard">
+		<ContactPicture {contact} />
+		<h3>{name}</h3>
+		<span>{format.emailDefault(contact)}</span>
+	</div>
+-->
+
+<style>
+</style>

package/lib/ContactPicture.svelte

@@ -0,0 +1,46 @@
+<script lang="ts">
+	import type { InitNoExternal } from '@axium/contacts';
+	import { colorHashRGB } from '@axium/core/color';
+	import { name as formatName } from '@axium/contacts/client/format';
+	import UserPFP from '@axium/client/components/UserPFP';
+	import { userInfo } from '@axium/client';
+
+	let { contact, isDefault = $bindable() }: { contact: InitNoExternal & { id: string }; isDefault?: boolean } = $props();
+
+	const name = $derived(formatName(contact));
+
+	const defaultImage = $derived(
+		`data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 50 50" style="background-color:${colorHashRGB(name ?? '\0')};display:flex;align-items:center;justify-content:center;">
+		<text x="23" y="28" style="font-family:sans-serif;font-weight:bold;" fill="white">${(name.replaceAll(/\W/g, '') || '?')[0]}</text>
+	</svg>`.replaceAll(/[\t\n]/g, '')
+	);
+
+	let src = $state(`/raw/contacts/pfp/${contact.id}`);
+</script>
+
+{#if contact.linkedUserId}
+	<UserPFP user={await userInfo(contact.linkedUserId)} bind:isDefault />
+{:else}
+	<img
+		class="ContactPicture"
+		{src}
+		alt={name}
+		onerror={() => {
+			isDefault = true;
+			src = defaultImage;
+		}}
+	/>
+{/if}
+
+<style>
+	img.ContactPicture {
+		width: var(--size, 2em);
+		height: var(--size, 2em);
+		border-radius: 50%;
+		border: 1px solid #8888;
+		vertical-align: middle;
+		margin-right: 0.5em;
+		/* see https://drafts.csswg.org/css-image-animation-1/ */
+		image-animation: stopped;
+	}
+</style>

package/lib/DateSelect.svelte

@@ -0,0 +1,25 @@
+<script lang="ts">
+	import { currentMonthNames, dateField } from '@axium/client';
+
+	let { day = $bindable<number>(), month = $bindable<number>(), year = $bindable<number>() } = $props();
+</script>
+
+<div class="ContactDateSelect">
+	<select bind:value={month}>
+		<option value="" disabled selected>{dateField('month')}</option>
+		{#each currentMonthNames as month, i}
+			<option value={i + 1}>{month}</option>
+		{/each}
+	</select>
+
+	<input type="number" bind:value={day} min="1" max="31" size="3" placeholder={dateField('day')} />
+	<input type="number" bind:value={year} min="0" max="9999" size="4" placeholder={dateField('year')} />
+</div>
+
+<style>
+	.ContactDateSelect {
+		display: flex;
+		gap: 0.5em;
+		align-items: center;
+	}
+</style>

package/lib/Discovery.svelte

@@ -0,0 +1,101 @@
+<script lang="ts">
+	import { text } from '@axium/client';
+	import { fetchAPI } from '@axium/client/requests';
+	import type { NoExternal } from '@axium/contacts';
+	import { format } from '@axium/contacts/client';
+	import { errorText } from 'ioium';
+
+	const { onSelect, exclude = [] }: { onSelect(id: string): unknown; exclude?: string[] } = $props();
+
+	let results = $state<NoExternal[]>([]),
+		value = $state<string>(),
+		gotError = $state<boolean>(false);
+
+	async function oninput() {
+		if (!value || !value.length) {
+			results = [];
+			return;
+		}
+
+		try {
+			results = await fetchAPI('POST', 'contact-discovery', value);
+		} catch (e) {
+			gotError = true;
+			console.warn('Can not use contact discovery:', errorText(e));
+			results = [];
+		}
+	}
+
+	function select(target: NoExternal) {
+		return (e: Event) => {
+			e.stopPropagation();
+			onSelect(target.id);
+			results = [];
+			value = format.name(target);
+		};
+	}
+</script>
+
+<input bind:value type="text" placeholder={text('contacts.Discovery.placeholder')} {oninput} />
+{#if !gotError && value}
+	<!-- Don't show results when we can't use the discovery API -->
+	<div class="results">
+		{#each results as result}
+			{#if !exclude.includes(result.id)}
+				<div class="result" onclick={select(result)}>
+					<span>{format.name(result)}</span>
+				</div>
+			{/if}
+		{:else}
+			<i>{text('contacts.Discovery.no_results')}</i>
+		{/each}
+	</div>
+{/if}
+
+<style>
+	:host {
+		anchor-scope: --discovery-input;
+	}
+
+	input {
+		anchor-name: --discovery-input;
+	}
+
+	input:focus + .results,
+	.results:active {
+		display: flex;
+		animation: var(--A-zoom);
+	}
+
+	.results {
+		position: fixed;
+		position-anchor: --discovery-input;
+		inset: anchor(bottom) anchor(right) auto anchor(left);
+		display: none;
+		flex-direction: column;
+		gap: 0.25em;
+		height: fit-content;
+		max-height: 25em;
+		background-color: var(--bg-accent);
+		border-radius: 0.25em 0.25em 0.75em 0.75em;
+		padding: 1em;
+		border: var(--border-accent);
+		align-items: stretch;
+
+		i {
+			text-align: center;
+		}
+	}
+
+	.result {
+		padding: 0.25em 0.75em;
+		border-radius: 0.5em;
+		display: inline-flex;
+		align-items: center;
+	}
+
+	.result:hover {
+		cursor: pointer;
+		background-color: var(--bg-strong);
+	}
+</style>