@k9o/core 1.1.1 → 1.3.0

package/src/index.ts

@@ -50,7 +50,6 @@ export type {
   StorageBucket, CreateBucketOptions, UpdateBucketOptions, StorageObject, UploadOptions, SignedUrlOptions,
   SignedUrl, RemovedObject, DeletedBucket,
 } from "./storage-buckets.ts";
-import { makeMetadataNamespace } from "./metadata.ts";
 import { makeMigrationsNamespace } from "./migrations.ts";
 import { makeFunctionsNamespace } from "./functions.ts";
 import { makePoliciesNamespace } from "./policies.ts";
@@ -83,6 +82,9 @@ export {
 export {
   validateBaseUrl,
   resolveBaseUrl,
+  parseApiHost,
+  DEFAULT_BASE_URL,
+  type ApiHost,
   validateSlug,
   projectPath,
   orgPath,
@@ -109,23 +111,21 @@ export type {
   StorageLocation, StorageLocationProvider, StorageLocationCustodyMode, StorageLocationProviderParams,
   CreateStorageLocationInput, UpdateStorageLocationInput, RetiredStorageLocation, StorageLocationTestResult,
 } from "./storage-locations.ts";
-export {
-  METADATA_OPERATORS,
-  type MetadataSlice, type MetadataOperator, type MetadataSurface,
-  type MetadataWhereClause, type MetadataQueryRecord, type MetadataQueryResult,
-  type MetadataQueryBuilder,
-} from "./metadata.ts";
 export type {
-  Migration, AppliedMigration, PendingMigration,
+  Migration, AppliedMigration, AppliedMigrationRow, SkippedMigrationRow, ApplyMigrationsResult, ApplyPendingResult,
+  PendingMigration, PendingMigrationStatus, QueuedMigration,
   Operation, ColumnSpec, IndexSpec, ColumnReferences,
   MigrationPolicy, CollectionPolicy, StorageBucketPolicy, RelationshipSpec, ActionRule,
 } from "./migrations.ts";
 export type { FunctionRecord, DeployFunctionInput } from "./functions.ts";
-export type { PolicyBundle, CreatePolicyInput, UpdatePolicyInput, ValidatePolicyResult } from "./policies.ts";
+export type {
+  PolicyBundle, PolicyDocument, PolicyPublishResult, PublishPolicyOptions, CreatePolicyInput, UpdatePolicyInput, ValidatePolicyResult,
+} from "./policies.ts";
 export type { AuditEvent, AuditQueryOpts } from "./audit.ts";
 export type { Org } from "./orgs.ts";
 export type {
   OrgMember,
+  OrgInviteResult,
   OrgGroup,
   OrgRoleGrant,
   OrgAuditEvent,
@@ -134,12 +134,16 @@ export type {
   SmtpTestEmailResult,
   OrgIdpProvider,
   CreateOrgIdpInput,
+  UpdateOrgIdpInput,
+  OrgIdpProviderKind,
+  OrgDefaultLlm,
 } from "./org.ts";
 export type {
   MyProfile,
   MySession,
+  UpdateMyProfileInput,
   MyApiToken,
-  MyNotification,
+  CreateMyApiTokenInput,
 } from "./me.ts";
 export type { ExtensionSlug, Extension } from "./extensions-bridge.ts";
 export type { GateClient } from "@k9o/gate";
@@ -188,6 +192,7 @@ export {
   type LLMInvokeParams,
   type LLMInvokeInput,
   type LLMResponse,
+  type LLMUsage,
   type LLMStreamChunk,
 } from "./compute/llms.ts";
 
@@ -203,9 +208,7 @@ export {
   type RealtimeFilter,
   type RealtimeEvent,
   type RealtimeSubscription,
-  type RealtimeTransportKind,
   type SubscribeOptions,
-  type ReplayInput,
 } from "./realtime.ts";
 
 /**
@@ -222,9 +225,6 @@ export type K9oClient = {
    *  `client.kibo.vault.secrets` (credential pre-create): this namespace only registers a caller-supplied
    *  `credentialRef` string, never creates or resolves one. */
   storage: ReturnType<typeof makeStorageNamespace>;
-  /** Cross-surface metadata query — `client.metadata.from(...).where(...).execute()`. Client-side
-   *  only until the gateway's Inc-2 route lands; see `metadata.ts` for status. */
-  metadata: ReturnType<typeof makeMetadataNamespace>;
   /** Migration lifecycle — `client.migrations.apply()` etc. */
   migrations: ReturnType<typeof makeMigrationsNamespace>;
   /** Function deploy + invoke — `client.functions.deploy()` etc. */
@@ -245,7 +245,7 @@ export type K9oClient = {
   compute: ReturnType<typeof makeComputeNamespace>;
   /** Platform AI primitives — `client.ai.embed({ model?, input })`. */
   ai: ReturnType<typeof makeAiNamespace>;
-  /** Realtime subscriptions — `client.realtime.subscribe()` / `.replay()`. */
+  /** Realtime subscriptions — `client.realtime.subscribe()` (SSE). */
   realtime: ReturnType<typeof makeRealtimeNamespace>;
   /** Gate (Identity-Aware Kernel) — composed from `@k9o/gate`. Available when projectSlug is bound on the client. */
   readonly gate: GateClient;
@@ -278,7 +278,6 @@ export function createClient(options: CreateClientOptions): K9oClient {
     from: makeFromFactory(config),
     projects: makeProjectsNamespace(config),
     storage: makeStorageNamespace(config),
-    metadata: makeMetadataNamespace(config),
     migrations: makeMigrationsNamespace(config),
     functions: makeFunctionsNamespace(config),
     policies: makePoliciesNamespace(config),

package/src/me.ts

@@ -7,14 +7,10 @@
  *
  * Wire mapping (gateway uses platform-plane / cross-org `/me/...` routes):
  *   - `client.me.profile.get/update` → GET/PATCH /me
- *   - `client.me.sessions.list/revoke` → GET/DELETE /me/sessions
- *   - `client.me.apiTokens.list/create/delete` → GET/POST/DELETE /me/api-tokens (not available yet)
- *   - `client.me.notifications.list/markRead` → GET/PATCH /me/notifications (not available yet)
- *   - `client.me.auditLog.query` → GET /me/audit-log (not available yet)
- *   - `client.me.dataExport.request` → POST /me/data-export (not available yet)
- *
- * Profile, sessions and MFA setup are served by the existing gateway routes
- * `me.ts` + `mfa.ts`.
+ *   - `client.me.sessions.list` → GET /me/sessions
+ *   - `client.me.sessions.revoke` → POST /auth/sessions/<sessionId>/revoke
+ *   - `client.me.sessions.revokeAll` → POST /me/sessions/revoke-all
+ *   - `client.me.apiTokens.list/create/delete` → GET/POST/DELETE /me/api-tokens
  */
 
 import { request, type HttpClientConfig } from "./http.ts";
@@ -22,48 +18,82 @@ import { orgPath } from "./url-grammar.ts";
 import type { Envelope } from "./envelope.ts";
 
 export type MyProfile = {
-  /** `u_<base62>`. */
+  /** `usr_<base62>`. */
   id: string;
   email: string;
-  displayName: string | null;
+  displayName: string;
+  mfaEnabled: boolean;
+  verifiedAt: string | null;
+  /** Set while the account is in its deletion grace period. */
+  deletedAt: string | null;
+  deletionRequestedAt: string | null;
+  deletionScheduledFor: string | null;
+  avatarUrl: string | null;
+  /** BCP 47 language tag, or `null` when unset. */
+  locale: string | null;
+  /** IANA time zone name, or `null` when unset. */
+  timezone: string | null;
   /** ISO 8601. */
   createdAt: string;
-  /** Last activity timestamp. */
-  lastActiveAt: string | null;
+  /** ISO 8601. */
+  updatedAt: string;
 };
 
 export type MySession = {
   /** `sess_<base62>`. */
   id: string;
-  /** Initial sign-in time. */
-  createdAt: string;
-  /** Most recent activity time. */
-  lastSeenAt: string;
+  userId: string;
+  /** Sign-in time. */
+  issuedAt: string;
+  expiresAt: string;
+  revokedAt: string | null;
+  mfaVerifiedAt: string | null;
   userAgent: string | null;
   ipAddress: string | null;
+  /** Always `null` for now. */
+  geoCountry: string | null;
   /** Whether this session is the one issuing the current request. */
-  current: boolean;
+  isCurrentSession: boolean;
+};
+
+/** Fields `profile.update` may change; `null` clears `locale` and `timezone`. */
+export type UpdateMyProfileInput = {
+  displayName?: string | undefined;
+  /** BCP 47 language tag, for example `de-DE`. */
+  locale?: string | null | undefined;
+  /** IANA time zone name, for example `Europe/Berlin`. */
+  timezone?: string | null | undefined;
 };
 
 export type MyApiToken = {
-  /** `tok_<base62>`. */
+  /** `pat_<base62>`. */
   id: string;
-  name: string;
+  userId: string;
+  orgId: string;
+  label: string;
+  scopeManifest: CreateMyApiTokenInput["scopeManifest"];
+  ttlSeconds: number;
   /** ISO 8601. */
   createdAt: string;
-  /** ISO 8601 or null for non-expiring tokens. */
-  expiresAt: string | null;
-  /** Last 4 chars for display. */
-  suffix: string;
-  scope: string;
+  /** ISO 8601. */
+  expiresAt: string;
+  lastUsedAt: string | null;
+  revokedReason: string | null;
+  status: "active" | "revoked" | "expired";
 };
 
-export type MyNotification = {
-  id: string;
-  type: string;
-  payload: Record<string, unknown>;
-  createdAt: string;
-  readAt: string | null;
+/** Body of POST /me/api-tokens. Each `scopeManifest` field narrows the token; `null` or absent leaves it unrestricted. */
+export type CreateMyApiTokenInput = {
+  label: string;
+  scopeManifest: {
+    operations?: ReadonlyArray<"read" | "write" | "admin"> | null | undefined;
+    projects?: ReadonlyArray<string> | null | undefined;
+    resourceClasses?: ReadonlyArray<string> | null | undefined;
+    collections?: Record<string, unknown> | null | undefined;
+    cidrs?: ReadonlyArray<string> | null | undefined;
+  };
+  /** Token lifetime in seconds (60 to 31536000). */
+  ttlSeconds?: number | undefined;
 };
 
 export function makeMeNamespace(config: HttpClientConfig) {
@@ -74,8 +104,8 @@ export function makeMeNamespace(config: HttpClientConfig) {
         return request(config, { method: "GET", path: orgPath("me") });
       },
 
-      /** PATCH /me — update mutable profile fields (displayName). */
-      async update(patch: { displayName?: string | null }): Promise<Envelope<MyProfile>> {
+      /** PATCH /me — update mutable profile fields (displayName, locale, timezone). */
+      async update(patch: UpdateMyProfileInput): Promise<Envelope<MyProfile>> {
         return request(config, { method: "PATCH", path: orgPath("me"), body: patch });
       },
     },
@@ -86,76 +116,30 @@ export function makeMeNamespace(config: HttpClientConfig) {
         return request(config, { method: "GET", path: orgPath("me/sessions") });
       },
 
-      /** DELETE /me/sessions/<sessionId> — revoke a specific session. */
+      /** POST /auth/sessions/<sessionId>/revoke — revoke a specific session. */
       async revoke(sessionId: string): Promise<Envelope<{ revoked: boolean }>> {
-        return request(config, { method: "DELETE", path: orgPath(`me/sessions/${encodeURIComponent(sessionId)}`) });
+        return request(config, { method: "POST", path: orgPath(`auth/sessions/${encodeURIComponent(sessionId)}/revoke`) });
       },
 
-      /** DELETE /me/sessions (no path) — revoke all sessions except the current one. */
+      /** POST /me/sessions/revoke-all — revoke all of the operator's sessions except the current one. */
       async revokeAll(): Promise<Envelope<{ revoked: number }>> {
-        return request(config, { method: "DELETE", path: orgPath("me/sessions") });
+        return request(config, { method: "POST", path: orgPath("me/sessions/revoke-all") });
       },
     },
 
-    /**
-     * API tokens for personal scripting. The gateway endpoints are not available yet,
-     * so these methods return K9O_NOT_FOUND until they ship.
-     */
+    /** Personal access tokens for scripting. */
     apiTokens: {
       async list(): Promise<Envelope<ReadonlyArray<MyApiToken>>> {
         return request(config, { method: "GET", path: orgPath("me/api-tokens") });
       },
 
-      async create(input: { name: string; expiresInDays?: number | undefined; scope?: string | undefined }): Promise<Envelope<MyApiToken & { token: string }>> {
+      async create(input: CreateMyApiTokenInput): Promise<Envelope<MyApiToken & { plaintext: string }>> {
         return request(config, { method: "POST", path: orgPath("me/api-tokens"), body: input });
       },
 
-      async delete(tokenId: string): Promise<Envelope<{ deleted: boolean }>> {
+      async delete(tokenId: string): Promise<Envelope<MyApiToken>> {
         return request(config, { method: "DELETE", path: orgPath(`me/api-tokens/${encodeURIComponent(tokenId)}`) });
       },
     },
-
-    /**
-     * Notifications — operator-targeted (account-level events). Forward-
-     * cycle substrate; methods route correctly when gateway ships.
-     */
-    notifications: {
-      async list(opts?: { unreadOnly?: boolean | undefined; limit?: number | undefined; cursor?: string | undefined }): Promise<Envelope<ReadonlyArray<MyNotification>>> {
-        return request(config, { method: "GET", path: orgPath("me/notifications"), query: opts });
-      },
-
-      async markRead(notificationId: string): Promise<Envelope<MyNotification>> {
-        return request(config, { method: "PATCH", path: orgPath(`me/notifications/${encodeURIComponent(notificationId)}`), body: { read: true } });
-      },
-
-      async markAllRead(): Promise<Envelope<{ marked: number }>> {
-        return request(config, { method: "PATCH", path: orgPath("me/notifications"), body: { read: true } });
-      },
-    },
-
-    /**
-     * Operator-self audit log — actions performed BY this operator across
-     * orgs. Distinct from `client.audit` (project-plane) and
-     * `client.org.auditLog` (org-plane).
-     */
-    auditLog: {
-      async query(opts?: { since?: string | undefined; until?: string | undefined; type?: string | undefined; limit?: number | undefined; cursor?: string | undefined }): Promise<Envelope<ReadonlyArray<{ id: string; type: string; occurredAt: string; payload: Record<string, unknown> }>>> {
-        return request(config, { method: "GET", path: orgPath("me/audit-log"), query: opts });
-      },
-    },
-
-    /**
-     * Personal data export per GDPR-style requests. Returns a job id
-     * the operator polls for completion.
-     */
-    dataExport: {
-      async request(input?: { format?: "json" | "csv" }): Promise<Envelope<{ jobId: string; status: "queued" | "in-progress" | "ready" }>> {
-        return request(config, { method: "POST", path: orgPath("me/data-export"), body: input ?? {} });
-      },
-
-      async status(jobId: string): Promise<Envelope<{ jobId: string; status: "queued" | "in-progress" | "ready" | "failed"; downloadUrl: string | null }>> {
-        return request(config, { method: "GET", path: orgPath(`me/data-export/${encodeURIComponent(jobId)}`) });
-      },
-    },
   };
 }

package/src/migrations.ts

@@ -152,25 +152,74 @@ export type Migration = {
 };
 
 /**
- * Applied-migration record returned by `list` + `get`.
+ * Applied-migration record returned by `list` + `get`. `get` also carries `opPayload`
+ * (the migration body as submitted, or `null` for old migrations).
  */
 export type AppliedMigration = {
   version: number;
   slug: string;
   checksum: string;
   appliedAt: string;
+  noPolicy: boolean;
+  affectedCollections: ReadonlyArray<string>;
+  opPayload?: unknown;
 };
 
+/** A migration that `apply` or `applyPending` just applied. Carries no `appliedAt`. */
+export type AppliedMigrationRow = {
+  version: number;
+  slug: string;
+  checksum: string;
+};
+
+/** A migration `apply` left alone, e.g. `already_applied`. */
+export type SkippedMigrationRow = {
+  version: number;
+  slug: string;
+  reason: string;
+};
+
+/** Result of `apply`. */
+export type ApplyMigrationsResult = {
+  applied: ReadonlyArray<AppliedMigrationRow>;
+  skipped: ReadonlyArray<SkippedMigrationRow>;
+};
+
+/** Result of `applyPending`: `pendingId` is the queued row that was applied. */
+export type ApplyPendingResult = ApplyMigrationsResult & {
+  pendingId: string;
+};
+
+export type PendingMigrationStatus = "queued" | "pending_approval" | "applied" | "rejected" | "cancelled";
+
 /**
  * Pending migration record returned by `listPending`.
  */
 export type PendingMigration = {
-  pendingId: string;
+  id: string;
   version: number;
   slug: string;
   checksum: string;
-  submittedAt: string;
-  submittedBy: string;
+  status: PendingMigrationStatus;
+  affectedCollections: ReadonlyArray<string>;
+  /** Approval that gates a `pending_approval` row, else `null`. */
+  approvalId: string | null;
+  queuedAt: string;
+  queuedBy: string;
+  decidedAt: string | null;
+  decidedBy: string | null;
+  decisionReason: string | null;
+};
+
+/** One row of the `queue` answer. */
+export type QueuedMigration = {
+  /** The pending id to pass to `applyPending`, `rejectPending` or `deletePending`. */
+  id: string;
+  version: number;
+  slug: string;
+  status: "queued" | "pending_approval";
+  approvalId: string | null;
+  affectedCollections: ReadonlyArray<string>;
 };
 
 function requireProjectSlug(config: HttpClientConfig): string {
@@ -183,7 +232,7 @@ function requireProjectSlug(config: HttpClientConfig): string {
 export function makeMigrationsNamespace(config: HttpClientConfig) {
   return {
     /** Apply migrations immediately (PROJECT_ADMIN minimum). */
-    async apply(input: { migrations: ReadonlyArray<Migration> }): Promise<Envelope<{ applied: ReadonlyArray<AppliedMigration> }>> {
+    async apply(input: { migrations: ReadonlyArray<Migration> }): Promise<Envelope<ApplyMigrationsResult>> {
       const slug = requireProjectSlug(config);
       return request(config, {
         method: "POST",
@@ -211,7 +260,7 @@ export function makeMigrationsNamespace(config: HttpClientConfig) {
     },
 
     /** Queue migrations for maker-checker approval. */
-    async queue(input: { migrations: ReadonlyArray<Migration> }): Promise<Envelope<{ pending: ReadonlyArray<PendingMigration> }>> {
+    async queue(input: { migrations: ReadonlyArray<Migration> }): Promise<Envelope<ReadonlyArray<QueuedMigration>>> {
       const slug = requireProjectSlug(config);
       return request(config, {
         method: "POST",
@@ -220,12 +269,13 @@ export function makeMigrationsNamespace(config: HttpClientConfig) {
       });
     },
 
-    /** List pending (queued, not yet approved) migrations. */
-    async listPending(): Promise<Envelope<ReadonlyArray<PendingMigration>>> {
+    /** List pending migrations: `queued` ones by default, or those with the given `status`. */
+    async listPending(opts?: { status?: PendingMigrationStatus | undefined }): Promise<Envelope<ReadonlyArray<PendingMigration>>> {
       const slug = requireProjectSlug(config);
       return request(config, {
         method: "GET",
         path: projectPath(slug, "migrations/pending"),
+        query: opts,
       });
     },
 
@@ -235,7 +285,7 @@ export function makeMigrationsNamespace(config: HttpClientConfig) {
      * migration awaiting a distinct-admin's review, is refused here and
      * needs its own approval flow, not this call).
      */
-    async applyPending(pendingId: string): Promise<Envelope<AppliedMigration>> {
+    async applyPending(pendingId: string): Promise<Envelope<ApplyPendingResult>> {
       const slug = requireProjectSlug(config);
       return request(config, {
         method: "POST",
@@ -244,7 +294,7 @@ export function makeMigrationsNamespace(config: HttpClientConfig) {
     },
 
     /** Reject a pending migration (transitions to rejected; does not apply). */
-    async rejectPending(pendingId: string, input?: { reason?: string }): Promise<Envelope<{ rejected: boolean }>> {
+    async rejectPending(pendingId: string, input?: { reason?: string }): Promise<Envelope<{ pendingId: string; status: "rejected" }>> {
       const slug = requireProjectSlug(config);
       return request(config, {
         method: "POST",
@@ -254,7 +304,7 @@ export function makeMigrationsNamespace(config: HttpClientConfig) {
     },
 
     /** Delete a pending migration from the queue. */
-    async deletePending(pendingId: string): Promise<Envelope<{ deleted: boolean }>> {
+    async deletePending(pendingId: string): Promise<Envelope<{ pendingId: string; status: "cancelled" }>> {
       const slug = requireProjectSlug(config);
       return request(config, {
         method: "DELETE",