@undefineds.co/models 0.1.0

package/dist/repository.js

@@ -0,0 +1,186 @@
+import { and, like, or } from '@undefineds.co/drizzle-solid';
+export function resolveRowId(row) {
+    if (!row)
+        return null;
+    // Try @id first (standard RDF format)
+    const subject = row['@id'] ?? row.subject;
+    if (typeof subject === 'string' && subject.length > 0)
+        return subject;
+    // Try id field
+    const id = row.id;
+    if (typeof id === 'string' && id.length > 0)
+        return id;
+    // Handle drizzle-solid insert result format: {success: true, source: 'http://...'}
+    const source = row.source;
+    if (typeof source === 'string' && source.length > 0)
+        return source;
+    return null;
+}
+export function isIriLikeIdentifier(value) {
+    return /^(?:[a-z][a-z0-9+.-]*:|\/)/i.test(value) || value.startsWith('#');
+}
+export function stripEntityIdentifiers(data) {
+    if (!data)
+        return {};
+    const next = {};
+    for (const [key, value] of Object.entries(data)) {
+        if (key === 'id' || key === '@id' || key === 'subject' || key === 'source')
+            continue;
+        next[key] = value;
+    }
+    return next;
+}
+function resolveExactTarget(input) {
+    if (typeof input === 'string') {
+        return isIriLikeIdentifier(input) ? { iri: input } : { locator: { id: input } };
+    }
+    const iri = input['@id'] ?? input.subject;
+    if (typeof iri === 'string' && iri.length > 0) {
+        return { iri };
+    }
+    return { locator: input };
+}
+export async function findExactRecord(db, table, target) {
+    const exact = resolveExactTarget(target);
+    return 'iri' in exact
+        ? await db.findByIri(table, exact.iri)
+        : await db.findByLocator(table, exact.locator);
+}
+export async function updateExactRecord(db, table, target, data) {
+    const exact = resolveExactTarget(target);
+    const payload = stripEntityIdentifiers(data);
+    return 'iri' in exact
+        ? await db.updateByIri(table, exact.iri, payload)
+        : await db.updateByLocator(table, exact.locator, payload);
+}
+export async function deleteExactRecord(db, table, target) {
+    const exact = resolveExactTarget(target);
+    return 'iri' in exact
+        ? await db.deleteByIri(table, exact.iri)
+        : await db.deleteByLocator(table, exact.locator);
+}
+export function createRepositoryDescriptor(options) {
+    const { namespace, table, searchableFields, defaultSort, cache, } = options;
+    const searchAccessor = options.searchAccessor ?? ((filters) => {
+        const value = filters ? filters.search : undefined;
+        return typeof value === 'string' ? value : undefined;
+    });
+    const transformRow = options.transform ?? ((row) => row);
+    const invalidations = {
+        create: options.invalidations?.create ?? ['list'],
+        update: options.invalidations?.update ?? ['list', 'detail'],
+        remove: options.invalidations?.remove ?? ['list', 'detail'],
+    };
+    const resolveColumn = (field) => {
+        const column = table[field];
+        if (column)
+            return column;
+        const tableName = table.config?.name;
+        return tableName ? `${tableName}.${field}` : field;
+    };
+    const buildWhereClause = (filters) => {
+        const clauses = [];
+        const term = searchAccessor(filters)?.trim();
+        if (term && searchableFields?.length) {
+            const pattern = `%${term}%`;
+            const searchClauses = searchableFields
+                .map((field) => like(resolveColumn(field), pattern));
+            if (searchClauses.length === 1) {
+                clauses.push(searchClauses[0]);
+            }
+            else if (searchClauses.length > 1) {
+                clauses.push(or(...searchClauses));
+            }
+        }
+        const customFilter = options.filter?.({ table, filters });
+        if (customFilter) {
+            clauses.push(customFilter);
+        }
+        if (clauses.length === 0)
+            return undefined;
+        return clauses.length === 1 ? clauses[0] : and(...clauses);
+    };
+    const list = async (db, filters) => {
+        let query = db.select().from(table);
+        const whereClause = buildWhereClause(filters);
+        if (whereClause) {
+            query = query.where(whereClause);
+        }
+        if (defaultSort) {
+            query = query.orderBy(resolveColumn(defaultSort.field), defaultSort.direction);
+        }
+        const rows = await query.execute();
+        return rows.map((row) => transformRow(row));
+    };
+    const detail = async (db, id) => {
+        const record = await findExactRecord(db, table, id);
+        return record ? transformRow(record) : null;
+    };
+    const create = options.disableMutations?.create
+        ? undefined
+        : async (db, input) => {
+            // Generate an ID if not provided
+            const inputId = input.id;
+            const generatedId = typeof inputId === 'string' && inputId.length > 0
+                ? inputId
+                : crypto.randomUUID();
+            const inputWithId = { ...input, id: generatedId };
+            const result = await db.insert(table).values(inputWithId).execute();
+            // drizzle-solid returns [{success, source}] or the created row
+            const firstResult = Array.isArray(result) ? result?.[0] : result;
+            // If result is actual row data (not drizzle-solid success format), return it
+            if (firstResult && typeof firstResult === 'object' && !('success' in firstResult)) {
+                return transformRow(firstResult);
+            }
+            // Handle drizzle-solid format: {success: true, source: "http://..."}
+            const sourceUrl = firstResult && typeof firstResult === 'object' && 'source' in firstResult
+                ? firstResult.source
+                : null;
+            // Return synthetic row immediately for optimistic update
+            // The real data will be fetched via invalidateQueries
+            const baseUrl = sourceUrl ? sourceUrl.replace(/\/[^/]+\.ttl$/, '') : '';
+            const syntheticId = sourceUrl
+                ? `${baseUrl}/${generatedId}.ttl`
+                : generatedId;
+            return {
+                ...inputWithId,
+                id: generatedId,
+                '@id': syntheticId,
+                subject: syntheticId,
+                source: sourceUrl,
+            };
+        };
+    const update = options.disableMutations?.update
+        ? undefined
+        : async (db, id, input) => {
+            await updateExactRecord(db, table, id, input);
+            const next = await detail(db, id);
+            if (!next) {
+                throw new Error(`Failed to load ${namespace} record after update`);
+            }
+            return next;
+        };
+    const remove = options.disableMutations?.remove
+        ? undefined
+        : async (db, id) => {
+            await deleteExactRecord(db, table, id);
+            return { id };
+        };
+    const resourcePath = typeof table.getResourcePath === 'function'
+        ? table.getResourcePath()
+        : (table.config?.base ?? '');
+    return {
+        namespace,
+        resourcePath,
+        searchableFields,
+        defaultSort,
+        cache,
+        invalidations,
+        list,
+        detail,
+        create,
+        update,
+        remove,
+    };
+}
+export const definePodRepository = createRepositoryDescriptor;

package/dist/schema.d.ts

@@ -0,0 +1 @@
+export { linxSchema } from './core.js';

package/dist/schema.js

@@ -0,0 +1 @@
+export { linxSchema } from './core.js';

package/dist/session/index.d.ts

@@ -0,0 +1 @@
+export { sessionSchema } from "./session.schema.js";

package/dist/session/index.js

@@ -0,0 +1 @@
+export { sessionSchema } from "./session.schema.js";

package/dist/session/session.schema.d.ts

@@ -0,0 +1 @@
+export { sessionSchema } from '../core.js';

package/dist/session/session.schema.js

@@ -0,0 +1 @@
+export { sessionSchema } from '../core.js';

package/dist/session.d.ts

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

package/dist/session.js

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

package/dist/settings/index.d.ts

@@ -0,0 +1 @@
+export { settingsTable, SETTING_KEYS, type SettingKey, type SettingsRow, type SettingsInsert, type SettingsUpdate } from "./settings.schema.js";

package/dist/settings/index.js

@@ -0,0 +1 @@
+export { settingsTable, SETTING_KEYS } from "./settings.schema.js";

package/dist/settings/settings.schema.d.ts

@@ -0,0 +1 @@
+export { settingsTable, SETTING_KEYS, type SettingKey, type SettingsRow, type SettingsInsert, type SettingsUpdate, } from '../core.js';

package/dist/settings/settings.schema.js

@@ -0,0 +1 @@
+export { settingsTable, SETTING_KEYS, } from '../core.js';

package/dist/settings.d.ts

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

package/dist/settings.js

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

package/dist/sidecar/index.d.ts

@@ -0,0 +1,2 @@
+export * from './sidecar-events.js';
+export * from './persistence-mapping.js';

package/dist/sidecar/index.js

@@ -0,0 +1,2 @@
+export * from './sidecar-events.js';
+export * from './persistence-mapping.js';

package/dist/sidecar/persistence-mapping.d.ts

@@ -0,0 +1,51 @@
+import type { ApprovalInsert, ApprovalUpdate } from '../approval.schema.js';
+import type { AuditInsert } from '../audit.schema.js';
+import type { GrantInsert } from '../grant.schema.js';
+import type { InboxNotificationInsert } from '../inbox-notification.schema.js';
+import type { ToolCallEvent, InboxApprovalEvent, SessionStateEvent } from './sidecar-events.js';
+export type ChatSessionProjection = {
+    chatId: string;
+    sessionStatus: 'active' | 'paused' | 'completed' | 'error';
+    policy?: string;
+    policyVersion?: string;
+};
+export type ApprovalProjectionInsert = Pick<ApprovalInsert, 'session' | 'toolCallId' | 'toolName' | 'target' | 'action' | 'risk' | 'status' | 'policyVersion'>;
+export type ApprovalProjectionUpdate = Partial<Pick<ApprovalUpdate, 'status' | 'assignedTo' | 'decisionBy' | 'decisionRole' | 'onBehalfOf' | 'reason' | 'policyVersion' | 'resolvedAt'>>;
+export type AuditProjectionInsert = Pick<AuditInsert, 'action' | 'actor' | 'actorRole' | 'onBehalfOf' | 'session' | 'toolCallId' | 'approval' | 'context' | 'policy' | 'policyVersion'>;
+export type GrantProjectionInsert = Pick<GrantInsert, 'target' | 'action' | 'effect' | 'riskCeiling' | 'decisionBy' | 'decisionRole' | 'onBehalfOf'>;
+export type InboxNotificationProjectionInsert = Pick<InboxNotificationInsert, 'actor' | 'object'>;
+export declare const SidecarEventToPodMapping: {
+    readonly tool_call_waiting_approval: {
+        readonly approval: "insert";
+        readonly inboxNotification: "insert";
+        readonly audit: null;
+        readonly grant: null;
+    };
+    readonly tool_call_approved_or_rejected: {
+        readonly approval: "update";
+        readonly inboxNotification: "insert";
+        readonly audit: "insert";
+        readonly grant: null;
+    };
+    readonly inbox_approval_resolved: {
+        readonly approval: "update";
+        readonly inboxNotification: "insert";
+        readonly audit: null;
+        readonly grant: null;
+    };
+    readonly session_state_terminal: {
+        readonly chat: "update";
+    };
+};
+export declare function hasPodScope(scope: {
+    target?: string;
+    action?: string;
+}): scope is {
+    target: string;
+    action: string;
+};
+export type SidecarPersistenceRuleKey = keyof typeof SidecarEventToPodMapping;
+export declare function isToolWaitingApproval(event: ToolCallEvent): boolean;
+export declare function isToolDecisionEvent(event: ToolCallEvent): boolean;
+export declare function isInboxResolved(event: InboxApprovalEvent): boolean;
+export declare function isSessionTerminal(event: SessionStateEvent): boolean;

package/dist/sidecar/persistence-mapping.js

@@ -0,0 +1,44 @@
+export const SidecarEventToPodMapping = {
+    // tool.call
+    tool_call_waiting_approval: {
+        approval: 'insert',
+        inboxNotification: 'insert',
+        audit: null,
+        grant: null,
+    },
+    tool_call_approved_or_rejected: {
+        approval: 'update',
+        inboxNotification: 'insert',
+        audit: 'insert',
+        grant: null,
+    },
+    // inbox.approval
+    inbox_approval_resolved: {
+        approval: 'update',
+        inboxNotification: 'insert',
+        audit: null,
+        grant: null,
+    },
+    // session.state
+    session_state_terminal: {
+        chat: 'update',
+    },
+};
+// Projection helpers (pure, no DB calls)
+// NOTE: CP0 scope is Pod-only. Only project events that provide a concrete ODRL target/action.
+export function hasPodScope(scope) {
+    return typeof scope.target === 'string' && scope.target.length > 0 && typeof scope.action === 'string' && scope.action.length > 0;
+}
+// Optional helpers for downstream implementers (pure, no DB calls)
+export function isToolWaitingApproval(event) {
+    return event.type === 'tool.call' && event.status === 'waiting_approval';
+}
+export function isToolDecisionEvent(event) {
+    return event.type === 'tool.call' && (event.status === 'approved' || event.status === 'rejected');
+}
+export function isInboxResolved(event) {
+    return event.type === 'inbox.approval' && event.status !== 'pending';
+}
+export function isSessionTerminal(event) {
+    return event.type === 'session.state' && (event.status === 'completed' || event.status === 'error');
+}