@terrantula/sdk 0.0.2 → 0.2.0

package/dist/local.d.ts

@@ -1,4 +1,5 @@
-import { a as SchemaFn, S as SnapshotOp, A as AuditExportConfigResponse, b as TestConnectionResponse, c as AuditExportRunResponse, E as ExportCatalogResult } from './audit-export-BJSNZ9ic.js';
+import { a as SchemaFn, S as SnapshotOp, A as AuditExportConfigResponse, b as TestConnectionResponse, c as AuditExportRunResponse, E as ExportCatalogResult, d as AdminAuditListResponse, e as AdminOrgListResponse, f as AdminOrgDetail, g as AdminSuspendResponse } from './audit-export-BtZTnt8a.js';
+import * as _terrantula_types from '@terrantula/types';
 import * as hono_utils_types from 'hono/utils/types';
 import * as zod from 'zod';
 
@@ -25,6 +26,7 @@ declare const createLocalClient: (options?: CreateLocalClientOptions) => {
             deletedAt: string | null;
             logo: string | null;
             metadata: string | null;
+            suspendedAt: string | null;
         }>;
         get: SchemaFn<zod.ZodObject<{
             id: zod.ZodString;
@@ -42,6 +44,7 @@ declare const createLocalClient: (options?: CreateLocalClientOptions) => {
             createdAt: string;
             metadata: string | null;
             deletedAt: string | null;
+            suspendedAt: string | null;
         }>;
         listUsers: SchemaFn<zod.ZodObject<{
             id: zod.ZodString;
@@ -89,6 +92,9 @@ declare const createLocalClient: (options?: CreateLocalClientOptions) => {
             createdAt: string;
             updatedAt: string;
             deletedAt: string | null;
+            banned: boolean;
+            banReason: string | null;
+            banExpires: string | null;
         }>;
         updateUserRole: SchemaFn<zod.ZodObject<{
             id: zod.ZodString;
@@ -96,12 +102,12 @@ declare const createLocalClient: (options?: CreateLocalClientOptions) => {
             role: zod.ZodEnum<["owner", "admin", "member"]>;
         }, "strip", zod.ZodTypeAny, {
             id: string;
-            userId: string;
             role: "member" | "owner" | "admin";
+            userId: string;
         }, {
             id: string;
-            userId: string;
             role: "member" | "owner" | "admin";
+            userId: string;
         }>, {
             error: string;
         } | {
@@ -1606,6 +1612,8 @@ declare const createLocalClient: (options?: CreateLocalClientOptions) => {
             updatedAt: string;
             projectId: string | null;
             envId: string;
+            deletionScheduledAt: string | null;
+            deletionGracePeriodSeconds: number | null;
         }[]>;
         syncStamp: SchemaFn<zod.ZodObject<{
             projectId: zod.ZodString;
@@ -2234,6 +2242,8 @@ declare const createLocalClient: (options?: CreateLocalClientOptions) => {
             updatedAt: string;
             projectId: string | null;
             envId: string;
+            deletionScheduledAt: string | null;
+            deletionGracePeriodSeconds: number | null;
         }[]>;
         get: SchemaFn<zod.ZodObject<{
             projectId: zod.ZodString;
@@ -2259,6 +2269,8 @@ declare const createLocalClient: (options?: CreateLocalClientOptions) => {
             updatedAt: string;
             projectId: string | null;
             envId: string;
+            deletionScheduledAt: string | null;
+            deletionGracePeriodSeconds: number | null;
         }>;
         create: SchemaFn<zod.ZodObject<{
             kind: zod.ZodLiteral<"Relationship">;
@@ -2305,6 +2317,8 @@ declare const createLocalClient: (options?: CreateLocalClientOptions) => {
             relationshipTypeName: string;
             fromEntityId: string;
             toEntityId: string;
+            deletionScheduledAt: string | null;
+            deletionGracePeriodSeconds: number | null;
         }>;
         delete: SchemaFn<zod.ZodObject<{
             projectId: zod.ZodString;
@@ -15953,6 +15967,7 @@ declare const createLocalClient: (options?: CreateLocalClientOptions) => {
             itemCount: number;
             deletionCount: number;
             force: boolean;
+            version: number;
         }[]>;
         get: SchemaFn<zod.ZodObject<{
             projectId: zod.ZodString;
@@ -16435,6 +16450,242 @@ declare const createLocalClient: (options?: CreateLocalClientOptions) => {
         }>;
         delete: (key: string) => Promise<unknown>;
     };
+    importSources: {
+        list: SchemaFn<zod.ZodObject<{
+            projectId: zod.ZodString;
+        }, "strip", zod.ZodTypeAny, {
+            projectId: string;
+        }, {
+            projectId: string;
+        }>, {
+            id: string;
+            projectId: string | null;
+            envId: string;
+            sourceKind: string;
+            sourceUri: string;
+            reconciliationPolicy: string;
+            lastScannedAt: string | null;
+            lastScanStatus: string | null;
+            lastScanSummary: hono_utils_types.JSONValue;
+            createdAt: string;
+            updatedAt: string;
+        }[]>;
+        get: SchemaFn<zod.ZodObject<{
+            projectId: zod.ZodString;
+            id: zod.ZodString;
+        }, "strip", zod.ZodTypeAny, {
+            id: string;
+            projectId: string;
+        }, {
+            id: string;
+            projectId: string;
+        }>, {
+            id: string;
+            projectId: string | null;
+            envId: string;
+            sourceKind: string;
+            sourceUri: string;
+            reconciliationPolicy: string;
+            lastScannedAt: string | null;
+            lastScanStatus: string | null;
+            lastScanSummary: hono_utils_types.JSONValue;
+            createdAt: string;
+            updatedAt: string;
+        }>;
+        registerOrUpdate: SchemaFn<zod.ZodObject<{
+            projectId: zod.ZodString;
+            envName: zod.ZodString;
+            sourceKind: zod.ZodEnum<["tf-state", "atmos-manifests"]>;
+            sourceUri: zod.ZodString;
+            reconciliationPolicy: zod.ZodOptional<zod.ZodEnum<["auto-update", "human-approval"]>>;
+        }, "strip", zod.ZodTypeAny, {
+            projectId: string;
+            envName: string;
+            sourceKind: "tf-state" | "atmos-manifests";
+            sourceUri: string;
+            reconciliationPolicy?: "auto-update" | "human-approval" | undefined;
+        }, {
+            projectId: string;
+            envName: string;
+            sourceKind: "tf-state" | "atmos-manifests";
+            sourceUri: string;
+            reconciliationPolicy?: "auto-update" | "human-approval" | undefined;
+        }>, {
+            id: string;
+            projectId: string | null;
+            envId: string;
+            sourceKind: string;
+            sourceUri: string;
+            reconciliationPolicy: string;
+            lastScannedAt: string | null;
+            lastScanStatus: string | null;
+            lastScanSummary: hono_utils_types.JSONValue;
+            createdAt: string;
+            updatedAt: string;
+        } | {
+            id: string;
+            createdAt: string;
+            updatedAt: string;
+            projectId: string | null;
+            envId: string;
+            sourceKind: string;
+            sourceUri: string;
+            reconciliationPolicy: string;
+            lastScannedAt: string | null;
+            lastScanStatus: string | null;
+            lastScanSummary: hono_utils_types.JSONValue;
+        }>;
+        rescan: SchemaFn<zod.ZodObject<{
+            projectId: zod.ZodString;
+            id: zod.ZodString;
+            envName: zod.ZodString;
+            items: zod.ZodArray<zod.ZodUnknown, "many">;
+            deletions: zod.ZodOptional<zod.ZodArray<zod.ZodObject<{
+                kind: zod.ZodString;
+                name: zod.ZodString;
+            }, "strip", zod.ZodTypeAny, {
+                name: string;
+                kind: string;
+            }, {
+                name: string;
+                kind: string;
+            }>, "many">>;
+        }, "strip", zod.ZodTypeAny, {
+            id: string;
+            projectId: string;
+            envName: string;
+            items: unknown[];
+            deletions?: {
+                name: string;
+                kind: string;
+            }[] | undefined;
+        }, {
+            id: string;
+            projectId: string;
+            envName: string;
+            items: unknown[];
+            deletions?: {
+                name: string;
+                kind: string;
+            }[] | undefined;
+        }>, {
+            scan: {
+                scanned: any;
+                succeeded: number;
+                failed: number;
+                proposalsCreated: number;
+            };
+            lastScannedAt: string;
+            lastScanStatus: string;
+        } | {
+            scan: {
+                scanned: any;
+                created: number;
+                failed: number;
+                proposalsCreated: number;
+            };
+            lastScannedAt: string;
+            lastScanStatus: string;
+        }>;
+        drift: SchemaFn<zod.ZodObject<{
+            projectId: zod.ZodString;
+            id: zod.ZodString;
+        }, "strip", zod.ZodTypeAny, {
+            id: string;
+            projectId: string;
+        }, {
+            id: string;
+            projectId: string;
+        }>, {
+            source: {
+                id: string;
+                projectId: string | null;
+                envId: string;
+                sourceKind: string;
+                sourceUri: string;
+                reconciliationPolicy: string;
+                lastScannedAt: string | null;
+                lastScanStatus: string | null;
+                lastScanSummary: hono_utils_types.JSONValue;
+                createdAt: string;
+                updatedAt: string;
+            };
+            totals: {
+                entities: number;
+                current: number;
+                stale: number;
+                missing: number;
+                pendingProposals: number;
+            };
+            entities: {
+                id: string;
+                name: string;
+                entityType: string;
+                lastSyncedAt: string | null;
+                driftStatus: _terrantula_types.DriftStatus | null;
+            }[];
+            pendingProposals: {
+                id: string;
+                importSourceId: string;
+                projectId: string | null;
+                envId: string;
+                entityId: string;
+                proposedChanges: hono_utils_types.JSONValue;
+                status: string;
+                createdAt: string;
+                decidedAt: string | null;
+                decidedBy: string | null;
+            }[];
+        }>;
+        approveProposal: SchemaFn<zod.ZodObject<{
+            projectId: zod.ZodString;
+            id: zod.ZodString;
+            proposalId: zod.ZodString;
+        }, "strip", zod.ZodTypeAny, {
+            id: string;
+            projectId: string;
+            proposalId: string;
+        }, {
+            id: string;
+            projectId: string;
+            proposalId: string;
+        }>, {
+            id: string;
+            importSourceId: string;
+            projectId: string | null;
+            envId: string;
+            entityId: string;
+            proposedChanges: hono_utils_types.JSONValue;
+            status: string;
+            createdAt: string;
+            decidedAt: string | null;
+            decidedBy: string | null;
+        }>;
+        rejectProposal: SchemaFn<zod.ZodObject<{
+            projectId: zod.ZodString;
+            id: zod.ZodString;
+            proposalId: zod.ZodString;
+        }, "strip", zod.ZodTypeAny, {
+            id: string;
+            projectId: string;
+            proposalId: string;
+        }, {
+            id: string;
+            projectId: string;
+            proposalId: string;
+        }>, {
+            id: string;
+            importSourceId: string;
+            projectId: string | null;
+            envId: string;
+            entityId: string;
+            proposedChanges: hono_utils_types.JSONValue;
+            status: string;
+            createdAt: string;
+            decidedAt: string | null;
+            decidedBy: string | null;
+        }>;
+    };
     exportCatalog: SchemaFn<zod.ZodObject<{
         projectId: zod.ZodString;
         envName: zod.ZodString;
@@ -16445,6 +16696,59 @@ declare const createLocalClient: (options?: CreateLocalClientOptions) => {
         projectId: string;
         envName: string;
     }>, ExportCatalogResult>;
+    admin: {
+        audit: {
+            list: SchemaFn<zod.ZodObject<{
+                actor: zod.ZodOptional<zod.ZodString>;
+                action: zod.ZodOptional<zod.ZodString>;
+                resourceKind: zod.ZodOptional<zod.ZodString>;
+                since: zod.ZodOptional<zod.ZodString>;
+                until: zod.ZodOptional<zod.ZodString>;
+                limit: zod.ZodOptional<zod.ZodNumber>;
+                offset: zod.ZodOptional<zod.ZodNumber>;
+            }, "strip", zod.ZodTypeAny, {
+                limit?: number | undefined;
+                offset?: number | undefined;
+                action?: string | undefined;
+                resourceKind?: string | undefined;
+                since?: string | undefined;
+                actor?: string | undefined;
+                until?: string | undefined;
+            }, {
+                limit?: number | undefined;
+                offset?: number | undefined;
+                action?: string | undefined;
+                resourceKind?: string | undefined;
+                since?: string | undefined;
+                actor?: string | undefined;
+                until?: string | undefined;
+            }>, AdminAuditListResponse>;
+        };
+        orgs: {
+            list: SchemaFn<zod.ZodObject<{}, "strip", zod.ZodTypeAny, {}, {}>, AdminOrgListResponse>;
+            get: SchemaFn<zod.ZodObject<{
+                id: zod.ZodString;
+            }, "strip", zod.ZodTypeAny, {
+                id: string;
+            }, {
+                id: string;
+            }>, AdminOrgDetail>;
+            suspend: SchemaFn<zod.ZodObject<{
+                id: zod.ZodString;
+            }, "strip", zod.ZodTypeAny, {
+                id: string;
+            }, {
+                id: string;
+            }>, AdminSuspendResponse>;
+            unsuspend: SchemaFn<zod.ZodObject<{
+                id: zod.ZodString;
+            }, "strip", zod.ZodTypeAny, {
+                id: string;
+            }, {
+                id: string;
+            }>, AdminSuspendResponse>;
+        };
+    };
 } & {
     pools: {
         list: SchemaFn<zod.ZodObject<{
@@ -16706,6 +17010,7 @@ declare const createLocalClient: (options?: CreateLocalClientOptions) => {
             itemCount: number;
             deletionCount: number;
             force: boolean;
+            version: number;
         }[]>;
         get: SchemaFn<zod.ZodObject<{
             projectId: zod.ZodString;

package/dist/local.js

@@ -1018,7 +1018,7 @@ var SERVER_FIELDS = /* @__PURE__ */ new Set(["id", "projectId", "envId", "create
 function stripServerFields(row) {
   const out = {};
   for (const [key, value] of Object.entries(row)) {
-    if (!SERVER_FIELDS.has(key)) out[key] = value;
+    if (!SERVER_FIELDS.has(key) && value !== null) out[key] = value;
   }
   return out;
 }
@@ -1045,9 +1045,13 @@ function createExportCatalogFn(proj, projEnv) {
         ...cells.map(
           (r) => ({ kind: "Cell", ...stripServerFields(r) })
         ),
-        ...relationshipTypes.map(
-          (r) => ({ kind: "RelationshipType", ...stripServerFields(r) })
-        ),
+        ...relationshipTypes.map((r) => {
+          const { fromEntityTypeName, toEntityTypeName, ...rest } = r;
+          const stripped = stripServerFields(rest);
+          if (fromEntityTypeName != null) stripped.from = fromEntityTypeName;
+          if (toEntityTypeName != null) stripped.to = toEntityTypeName;
+          return { kind: "RelationshipType", ...stripped };
+        }),
         ...actions.map(
           (r) => ({ kind: "Action", ...stripServerFields(r) })
         ),
@@ -1449,6 +1453,199 @@ function createUserPreferencesClient(baseUrl, hcOpts) {
   };
 }
 
+// src/import-sources.ts
+var import_zod17 = require("zod");
+var SourceKindEnum = import_zod17.z.enum(["tf-state", "atmos-manifests"]);
+var PolicyEnum = import_zod17.z.enum(["auto-update", "human-approval"]);
+function createImportSourcesClient(proj) {
+  return {
+    list: withSchema(
+      import_zod17.z.object({ projectId: import_zod17.z.string().describe("Project ID") }),
+      (params) => call(proj(params.projectId)["import-sources"].$get())
+    ),
+    get: withSchema(
+      import_zod17.z.object({
+        projectId: import_zod17.z.string().describe("Project ID"),
+        id: import_zod17.z.string().uuid().describe("ImportSource ID")
+      }),
+      (params) => call(proj(params.projectId)["import-sources"][":id"].$get({ param: { id: params.id } }))
+    ),
+    registerOrUpdate: withSchema(
+      import_zod17.z.object({
+        projectId: import_zod17.z.string().describe("Project ID"),
+        envName: import_zod17.z.string().describe("Env name the source belongs to"),
+        sourceKind: SourceKindEnum,
+        sourceUri: import_zod17.z.string().describe("Stable URI identifying the source"),
+        reconciliationPolicy: PolicyEnum.optional()
+      }),
+      (params) => {
+        const { projectId, ...body } = params;
+        return call(proj(projectId)["import-sources"].$post({ json: body }));
+      }
+    ),
+    rescan: withSchema(
+      import_zod17.z.object({
+        projectId: import_zod17.z.string(),
+        id: import_zod17.z.string().uuid(),
+        envName: import_zod17.z.string(),
+        items: import_zod17.z.array(import_zod17.z.unknown()),
+        deletions: import_zod17.z.array(import_zod17.z.object({ kind: import_zod17.z.string(), name: import_zod17.z.string() })).optional()
+      }),
+      (params) => {
+        const { projectId, id, ...body } = params;
+        return call(
+          proj(projectId)["import-sources"][":id"].rescan.$post({
+            param: { id },
+            // why: the Hono RPC type for the body is the AnyKindSchema union;
+            // the SDK accepts `unknown[]` so callers don't have to re-import the
+            // entire schema graph just to construct an apply bundle.
+            json: body
+          })
+        );
+      }
+    ),
+    drift: withSchema(
+      import_zod17.z.object({
+        projectId: import_zod17.z.string(),
+        id: import_zod17.z.string().uuid()
+      }),
+      (params) => call(proj(params.projectId)["import-sources"][":id"].drift.$get({ param: { id: params.id } }))
+    ),
+    approveProposal: withSchema(
+      import_zod17.z.object({
+        projectId: import_zod17.z.string(),
+        id: import_zod17.z.string().uuid(),
+        proposalId: import_zod17.z.string().uuid()
+      }),
+      (params) => call(
+        proj(params.projectId)["import-sources"][":id"]["drift-proposals"][":proposalId"].approve.$post({
+          param: { id: params.id, proposalId: params.proposalId }
+        })
+      )
+    ),
+    rejectProposal: withSchema(
+      import_zod17.z.object({
+        projectId: import_zod17.z.string(),
+        id: import_zod17.z.string().uuid(),
+        proposalId: import_zod17.z.string().uuid()
+      }),
+      (params) => call(
+        proj(params.projectId)["import-sources"][":id"]["drift-proposals"][":proposalId"].reject.$post({
+          param: { id: params.id, proposalId: params.proposalId }
+        })
+      )
+    )
+  };
+}
+
+// src/admin.ts
+var import_zod18 = require("zod");
+async function rawRequest2(baseUrl, hcOpts, path, init = {}) {
+  const fetchImpl = hcOpts?.fetch ?? fetch;
+  const rawHeaders = hcOpts?.headers;
+  const resolvedHeaders = typeof rawHeaders === "function" ? await rawHeaders() : rawHeaders ?? {};
+  return fetchImpl(`${baseUrl}${path}`, {
+    ...init,
+    headers: {
+      ...resolvedHeaders,
+      ...init.headers
+    }
+  });
+}
+async function callRaw2(res) {
+  if (!res.ok) {
+    let message = fallbackMessage(res.status);
+    try {
+      const body = await res.json();
+      if (body.error) message = body.error;
+    } catch {
+    }
+    throw new TerrantulaError(res.status, { error: message });
+  }
+  return res.json();
+}
+function createAdminClient(baseUrl, hcOpts) {
+  return {
+    audit: {
+      /**
+       * GET /admin/audit
+       * List super-admin audit events with optional filters.
+       */
+      list: withSchema(
+        import_zod18.z.object({
+          actor: import_zod18.z.string().optional().describe("Filter by actor user ID"),
+          action: import_zod18.z.string().optional().describe("Filter by action name"),
+          resourceKind: import_zod18.z.string().optional().describe("Filter by resource kind"),
+          since: import_zod18.z.string().optional().describe("ISO 8601 datetime lower bound"),
+          until: import_zod18.z.string().optional().describe("ISO 8601 datetime upper bound"),
+          limit: import_zod18.z.coerce.number().int().min(1).max(200).optional().describe("Max results (1-200)"),
+          offset: import_zod18.z.coerce.number().int().min(0).optional().describe("Pagination offset")
+        }),
+        async (params) => {
+          const qs = new URLSearchParams();
+          if (params.actor !== void 0) qs.set("actor", params.actor);
+          if (params.action !== void 0) qs.set("action", params.action);
+          if (params.resourceKind !== void 0) qs.set("resourceKind", params.resourceKind);
+          if (params.since !== void 0) qs.set("since", params.since);
+          if (params.until !== void 0) qs.set("until", params.until);
+          if (params.limit !== void 0) qs.set("limit", String(params.limit));
+          if (params.offset !== void 0) qs.set("offset", String(params.offset));
+          const search = qs.toString();
+          return callRaw2(
+            await rawRequest2(baseUrl, hcOpts, `/admin/audit${search ? `?${search}` : ""}`)
+          );
+        }
+      )
+    },
+    orgs: {
+      /**
+       * GET /admin/orgs
+       * List all organizations across tenants with member + project counts.
+       */
+      list: withSchema(
+        import_zod18.z.object({}),
+        async () => callRaw2(
+          await rawRequest2(baseUrl, hcOpts, "/admin/orgs")
+        )
+      ),
+      /**
+       * GET /admin/orgs/:id
+       * Detail view: org fields + member list + project list.
+       */
+      get: withSchema(
+        import_zod18.z.object({ id: import_zod18.z.string().describe("Organization ID") }),
+        async (params) => callRaw2(
+          await rawRequest2(baseUrl, hcOpts, `/admin/orgs/${params.id}`)
+        )
+      ),
+      /**
+       * POST /admin/orgs/:id/suspend
+       * Set suspended_at = now(). Idempotent.
+       */
+      suspend: withSchema(
+        import_zod18.z.object({ id: import_zod18.z.string().describe("Organization ID") }),
+        async (params) => callRaw2(
+          await rawRequest2(baseUrl, hcOpts, `/admin/orgs/${params.id}/suspend`, {
+            method: "POST"
+          })
+        )
+      ),
+      /**
+       * POST /admin/orgs/:id/unsuspend
+       * Clear suspended_at.
+       */
+      unsuspend: withSchema(
+        import_zod18.z.object({ id: import_zod18.z.string().describe("Organization ID") }),
+        async (params) => callRaw2(
+          await rawRequest2(baseUrl, hcOpts, `/admin/orgs/${params.id}/unsuspend`, {
+            method: "POST"
+          })
+        )
+      )
+    }
+  };
+}
+
 // src/index.ts
 var createClient = (baseUrl, options = {}) => {
   const opts = typeof options === "string" || typeof options === "function" ? { token: options } : options;
@@ -1482,7 +1679,9 @@ var createClient = (baseUrl, options = {}) => {
     notifications: createNotificationsClient(baseUrl, hcOpts),
     auditExport: createAuditExportClient(baseUrl, hcOpts),
     userPreferences: createUserPreferencesClient(baseUrl, hcOpts),
-    exportCatalog
+    importSources: createImportSourcesClient(proj),
+    exportCatalog,
+    admin: createAdminClient(baseUrl, hcOpts)
   };
   let warnedPools = false;
   let warnedApplyRevisions = false;

package/dist/local.mjs

@@ -1,6 +1,6 @@
 import {
   createClient
-} from "./chunk-NTU2AEMP.mjs";
+} from "./chunk-WYOV3M2X.mjs";
 
 // src/local.ts
 import { createLocalApp, openLocalDb } from "@terrantula/local";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@terrantula/sdk",
-  "version": "0.0.2",
+  "version": "0.2.0",
   "description": "TypeScript SDK for Terrantula — the multi-tenant entity-graph control plane that herds Terraform/OpenTofu cattle.",
   "keywords": [
     "terrantula",
@@ -62,8 +62,8 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@terrantula/local": "^0.0.2",
-    "@terrantula/types": "^0.0.2",
+    "@terrantula/local": "^0.0.3",
+    "@terrantula/types": "^0.0.3",
     "hono": "^4.4.0",
     "zod": "^3.22.0"
   },