@onmyway133/asc-cli 1.0.1 → 1.0.3

package/src/commands/signing.ts

@@ -1,4 +1,15 @@
-import { ascFetch, ascFetchAll } from "../api/client.ts"
+import {
+  certificatesGetCollection,
+  certificatesGetInstance,
+  certificatesDeleteInstance,
+  devicesGetCollection,
+  devicesCreateInstance,
+  bundleIdsGetCollection,
+  bundleIdsCreateInstance,
+  profilesGetCollection,
+  profilesDeleteInstance,
+} from "../api/generated/sdk.gen.ts"
+import { throwOnError } from "../api/client.ts"
 import { detectFormat, formatDate, printJSON, printSuccess, printTable } from "../utils/output.ts"
 
 // ---- Certificates ----
@@ -7,62 +18,45 @@ export async function certificatesList(opts: {
   type?: string
   output?: string
 } = {}): Promise<void> {
-  const params: Record<string, string> = {
-    "fields[certificates]": "certificateType,displayName,expirationDate,serialNumber,platform",
+  const query: Record<string, unknown> = {
+    "fields[certificates]": ["certificateType", "displayName", "expirationDate", "serialNumber", "platform"],
   }
-  if (opts.type) params["filter[certificateType]"] = opts.type
-  const items = await ascFetchAll<{
-    id: string
-    attributes: {
-      certificateType?: string
-      displayName?: string
-      expirationDate?: string
-      serialNumber?: string
-      platform?: string
-    }
-  }>("/v1/certificates", { params })
+  if (opts.type) query["filter[certificateType]"] = [opts.type]
+
+  const result = await certificatesGetCollection({ query: query as never })
+  const data = throwOnError(result)
+  const items = data.data
   const fmt = detectFormat(opts.output)
   if (fmt === "json") { printJSON(items); return }
   printTable(
     ["ID", "Name", "Type", "Expires", "Serial"],
     items.map(c => [
       c.id,
-      c.attributes.displayName ?? "-",
-      c.attributes.certificateType ?? "-",
-      formatDate(c.attributes.expirationDate ?? ""),
-      c.attributes.serialNumber ?? "-",
+      c.attributes?.displayName ?? "-",
+      c.attributes?.certificateType ?? "-",
+      formatDate(c.attributes?.expirationDate ?? ""),
+      c.attributes?.serialNumber ?? "-",
     ]),
     `Certificates (${items.length})`,
   )
 }
 
 export async function certificateGet(certId: string, opts: { output?: string } = {}): Promise<void> {
-  const result = await ascFetch<{
-    data: {
-      id: string
-      attributes: {
-        certificateType?: string
-        displayName?: string
-        expirationDate?: string
-        serialNumber?: string
-        platform?: string
-        certificateContent?: string
-      }
-    }
-  }>(`/v1/certificates/${certId}`)
+  const result = await certificatesGetInstance({ path: { id: certId } })
+  const data = throwOnError(result)
   const fmt = detectFormat(opts.output)
-  if (fmt === "json") { printJSON(result.data.data); return }
-  const a = result.data.data.attributes
-  console.log(`ID:          ${result.data.data.id}`)
-  console.log(`Name:        ${a.displayName ?? "-"}`)
-  console.log(`Type:        ${a.certificateType ?? "-"}`)
-  console.log(`Expires:     ${formatDate(a.expirationDate ?? "")}`)
-  console.log(`Serial:      ${a.serialNumber ?? "-"}`)
-  console.log(`Platform:    ${a.platform ?? "-"}`)
+  if (fmt === "json") { printJSON(data.data); return }
+  const a = data.data.attributes
+  console.log(`ID:          ${data.data.id}`)
+  console.log(`Name:        ${a?.displayName ?? "-"}`)
+  console.log(`Type:        ${a?.certificateType ?? "-"}`)
+  console.log(`Expires:     ${formatDate(a?.expirationDate ?? "")}`)
+  console.log(`Serial:      ${a?.serialNumber ?? "-"}`)
+  console.log(`Platform:    ${a?.platform ?? "-"}`)
 }
 
 export async function certificateRevoke(certId: string): Promise<void> {
-  await ascFetch(`/v1/certificates/${certId}`, { method: "DELETE" })
+  await certificatesDeleteInstance({ path: { id: certId } })
   printSuccess(`Certificate ${certId} revoked`)
 }
 
@@ -73,34 +67,26 @@ export async function devicesList(opts: {
   status?: string
   output?: string
 } = {}): Promise<void> {
-  const params: Record<string, string> = {
-    "fields[devices]": "name,deviceClass,model,udid,platform,status,addedDate",
+  const query: Record<string, unknown> = {
+    "fields[devices]": ["name", "deviceClass", "model", "udid", "platform", "status", "addedDate"],
   }
-  if (opts.platform) params["filter[platform]"] = opts.platform
-  if (opts.status) params["filter[status]"] = opts.status
-  const items = await ascFetchAll<{
-    id: string
-    attributes: {
-      name?: string
-      deviceClass?: string
-      model?: string
-      udid?: string
-      platform?: string
-      status?: string
-      addedDate?: string
-    }
-  }>("/v1/devices", { params })
+  if (opts.platform) query["filter[platform]"] = [opts.platform]
+  if (opts.status) query["filter[status]"] = [opts.status]
+
+  const result = await devicesGetCollection({ query: query as never })
+  const data = throwOnError(result)
+  const items = data.data
   const fmt = detectFormat(opts.output)
   if (fmt === "json") { printJSON(items); return }
   printTable(
     ["ID", "Name", "Model", "Platform", "Status", "UDID"],
     items.map(d => [
       d.id,
-      d.attributes.name ?? "-",
-      d.attributes.model ?? d.attributes.deviceClass ?? "-",
-      d.attributes.platform ?? "-",
-      d.attributes.status ?? "-",
-      d.attributes.udid ?? "-",
+      d.attributes?.name ?? "-",
+      d.attributes?.model ?? d.attributes?.deviceClass ?? "-",
+      d.attributes?.platform ?? "-",
+      d.attributes?.status ?? "-",
+      d.attributes?.udid ?? "-",
     ]),
     `Devices (${items.length})`,
   )
@@ -111,16 +97,16 @@ export async function deviceRegister(opts: {
   udid: string
   platform: string
 }): Promise<void> {
-  const result = await ascFetch<{ data: { id: string } }>("/v1/devices", {
-    method: "POST",
+  const result = await devicesCreateInstance({
     body: {
       data: {
         type: "devices",
-        attributes: { name: opts.name, udid: opts.udid, platform: opts.platform },
+        attributes: { name: opts.name, udid: opts.udid, platform: opts.platform as never },
       },
     },
   })
-  printSuccess(`Device registered: ${result.data.data.id} (${opts.udid})`)
+  const data = throwOnError(result)
+  printSuccess(`Device registered: ${data.data.id} (${opts.udid})`)
 }
 
 // ---- Bundle IDs ----
@@ -130,25 +116,25 @@ export async function bundleIdsList(opts: {
   identifier?: string
   output?: string
 } = {}): Promise<void> {
-  const params: Record<string, string> = {
-    "fields[bundleIds]": "name,identifier,platform,seedId",
+  const query: Record<string, unknown> = {
+    "fields[bundleIds]": ["name", "identifier", "platform", "seedId"],
   }
-  if (opts.platform) params["filter[platform]"] = opts.platform
-  if (opts.identifier) params["filter[identifier]"] = opts.identifier
-  const items = await ascFetchAll<{
-    id: string
-    attributes: { name?: string; identifier?: string; platform?: string; seedId?: string }
-  }>("/v1/bundleIds", { params })
+  if (opts.platform) query["filter[platform]"] = [opts.platform]
+  if (opts.identifier) query["filter[identifier]"] = [opts.identifier]
+
+  const result = await bundleIdsGetCollection({ query: query as never })
+  const data = throwOnError(result)
+  const items = data.data
   const fmt = detectFormat(opts.output)
   if (fmt === "json") { printJSON(items); return }
   printTable(
     ["ID", "Name", "Identifier", "Platform", "Seed ID"],
     items.map(b => [
       b.id,
-      b.attributes.name ?? "-",
-      b.attributes.identifier ?? "-",
-      b.attributes.platform ?? "-",
-      b.attributes.seedId ?? "-",
+      b.attributes?.name ?? "-",
+      b.attributes?.identifier ?? "-",
+      b.attributes?.platform ?? "-",
+      b.attributes?.seedId ?? "-",
     ]),
     `Bundle IDs (${items.length})`,
   )
@@ -159,16 +145,16 @@ export async function bundleIdRegister(opts: {
   identifier: string
   platform: string
 }): Promise<void> {
-  const result = await ascFetch<{ data: { id: string } }>("/v1/bundleIds", {
-    method: "POST",
+  const result = await bundleIdsCreateInstance({
     body: {
       data: {
         type: "bundleIds",
-        attributes: { name: opts.name, identifier: opts.identifier, platform: opts.platform },
+        attributes: { name: opts.name, identifier: opts.identifier, platform: opts.platform as never },
       },
     },
   })
-  printSuccess(`Bundle ID registered: ${result.data.data.id} (${opts.identifier})`)
+  const data = throwOnError(result)
+  printSuccess(`Bundle ID registered: ${data.data.id} (${opts.identifier})`)
 }
 
 // ---- Provisioning Profiles ----
@@ -178,37 +164,31 @@ export async function profilesList(opts: {
   name?: string
   output?: string
 } = {}): Promise<void> {
-  const params: Record<string, string> = {
-    "fields[profiles]": "name,profileType,profileState,expirationDate,uuid",
+  const query: Record<string, unknown> = {
+    "fields[profiles]": ["name", "profileType", "profileState", "expirationDate", "uuid"],
   }
-  if (opts.type) params["filter[profileType]"] = opts.type
-  if (opts.name) params["filter[name]"] = opts.name
-  const items = await ascFetchAll<{
-    id: string
-    attributes: {
-      name?: string
-      profileType?: string
-      profileState?: string
-      expirationDate?: string
-      uuid?: string
-    }
-  }>("/v1/profiles", { params })
+  if (opts.type) query["filter[profileType]"] = [opts.type]
+  if (opts.name) query["filter[name]"] = [opts.name]
+
+  const result = await profilesGetCollection({ query: query as never })
+  const data = throwOnError(result)
+  const items = data.data
   const fmt = detectFormat(opts.output)
   if (fmt === "json") { printJSON(items); return }
   printTable(
     ["ID", "Name", "Type", "State", "Expires"],
     items.map(p => [
       p.id,
-      p.attributes.name ?? "-",
-      p.attributes.profileType ?? "-",
-      p.attributes.profileState ?? "-",
-      formatDate(p.attributes.expirationDate ?? ""),
+      p.attributes?.name ?? "-",
+      p.attributes?.profileType ?? "-",
+      p.attributes?.profileState ?? "-",
+      formatDate(p.attributes?.expirationDate ?? ""),
     ]),
     `Provisioning Profiles (${items.length})`,
   )
 }
 
 export async function profileDelete(profileId: string): Promise<void> {
-  await ascFetch(`/v1/profiles/${profileId}`, { method: "DELETE" })
+  await profilesDeleteInstance({ path: { id: profileId } })
   printSuccess(`Profile ${profileId} deleted`)
 }

package/src/commands/subscriptions.ts

@@ -1,20 +1,28 @@
-import { ascFetch, ascFetchAll } from "../api/client.ts"
+import {
+  appsSubscriptionGroupsGetToManyRelated,
+  subscriptionGroupsCreateInstance,
+  subscriptionGroupsSubscriptionsGetToManyRelated,
+  subscriptionsGetInstance,
+  subscriptionsCreateInstance,
+  subscriptionsPricesGetToManyRelated,
+} from "../api/generated/sdk.gen.ts"
+import { throwOnError } from "../api/client.ts"
 import { detectFormat, printJSON, printSuccess, printTable, truncate } from "../utils/output.ts"
 
 // ---- Subscription Groups ----
 
 export async function subscriptionGroupsList(opts: { appId: string; output?: string }): Promise<void> {
-  const items = await ascFetchAll<{
-    id: string
-    attributes: { referenceName?: string; subscriptions?: number }
-  }>(`/v1/apps/${opts.appId}/subscriptionGroups`, {
-    params: { "fields[subscriptionGroups]": "referenceName,subscriptions" },
+  const result = await appsSubscriptionGroupsGetToManyRelated({
+    path: { id: opts.appId },
+    query: { "fields[subscriptionGroups]": ["referenceName"] },
   })
+  const data = throwOnError(result)
+  const items = data.data
   const fmt = detectFormat(opts.output)
   if (fmt === "json") { printJSON(items); return }
   printTable(
     ["Group ID", "Reference Name"],
-    items.map(g => [g.id, g.attributes.referenceName ?? "-"]),
+    items.map(g => [g.id, g.attributes?.referenceName ?? "-"]),
     `Subscription Groups (${items.length})`,
   )
 }
@@ -23,8 +31,7 @@ export async function subscriptionGroupCreate(opts: {
   appId: string
   referenceName: string
 }): Promise<void> {
-  const result = await ascFetch<{ data: { id: string } }>("/v1/subscriptionGroups", {
-    method: "POST",
+  const result = await subscriptionGroupsCreateInstance({
     body: {
       data: {
         type: "subscriptionGroups",
@@ -33,66 +40,48 @@ export async function subscriptionGroupCreate(opts: {
       },
     },
   })
-  printSuccess(`Created subscription group: ${result.data.data.id}`)
+  const data = throwOnError(result)
+  printSuccess(`Created subscription group: ${data.data.id}`)
 }
 
 // ---- Subscriptions ----
 
 export async function subscriptionsList(opts: { groupId: string; output?: string }): Promise<void> {
-  const items = await ascFetchAll<{
-    id: string
-    attributes: {
-      name?: string
-      productId?: string
-      subscriptionPeriod?: string
-      state?: string
-      familySharable?: boolean
-    }
-  }>(`/v1/subscriptionGroups/${opts.groupId}/subscriptions`, {
-    params: { "fields[subscriptions]": "name,productId,subscriptionPeriod,state,familySharable" },
+  const result = await subscriptionGroupsSubscriptionsGetToManyRelated({
+    path: { id: opts.groupId },
+    query: { "fields[subscriptions]": ["name", "productId", "subscriptionPeriod", "state", "familySharable"] },
   })
+  const data = throwOnError(result)
+  const items = data.data
   const fmt = detectFormat(opts.output)
   if (fmt === "json") { printJSON(items); return }
   printTable(
     ["ID", "Name", "Product ID", "Period", "State"],
     items.map(s => [
       s.id,
-      truncate(s.attributes.name ?? "-", 30),
-      s.attributes.productId ?? "-",
-      s.attributes.subscriptionPeriod ?? "-",
-      s.attributes.state ?? "-",
+      truncate(s.attributes?.name ?? "-", 30),
+      s.attributes?.productId ?? "-",
+      s.attributes?.subscriptionPeriod ?? "-",
+      s.attributes?.state ?? "-",
     ]),
     `Subscriptions (${items.length})`,
   )
 }
 
 export async function subscriptionGet(subId: string, opts: { output?: string } = {}): Promise<void> {
-  const result = await ascFetch<{
-    data: {
-      id: string
-      attributes: {
-        name?: string
-        productId?: string
-        subscriptionPeriod?: string
-        state?: string
-        familySharable?: boolean
-        reviewNote?: string
-        availableInAllTerritories?: boolean
-        groupLevel?: number
-      }
-    }
-  }>(`/v1/subscriptions/${subId}`)
+  const result = await subscriptionsGetInstance({ path: { id: subId } })
+  const data = throwOnError(result)
   const fmt = detectFormat(opts.output)
-  if (fmt === "json") { printJSON(result.data.data); return }
-  const a = result.data.data.attributes
-  console.log(`ID:            ${result.data.data.id}`)
-  console.log(`Name:          ${a.name ?? "-"}`)
-  console.log(`Product ID:    ${a.productId ?? "-"}`)
-  console.log(`Period:        ${a.subscriptionPeriod ?? "-"}`)
-  console.log(`State:         ${a.state ?? "-"}`)
-  console.log(`Group Level:   ${a.groupLevel ?? "-"}`)
-  console.log(`Family Share:  ${a.familySharable ?? false}`)
-  console.log(`All Territ.:   ${a.availableInAllTerritories ?? false}`)
+  if (fmt === "json") { printJSON(data.data); return }
+  const a = data.data.attributes
+  console.log(`ID:            ${data.data.id}`)
+  console.log(`Name:          ${a?.name ?? "-"}`)
+  console.log(`Product ID:    ${a?.productId ?? "-"}`)
+  console.log(`Period:        ${a?.subscriptionPeriod ?? "-"}`)
+  console.log(`State:         ${a?.state ?? "-"}`)
+  console.log(`Group Level:   ${a?.groupLevel ?? "-"}`)
+  console.log(`Family Share:  ${a?.familySharable ?? false}`)
+  console.log(`All Territ.:   ${(a as Record<string, unknown>)?.availableInAllTerritories ?? false}`)
 }
 
 export async function subscriptionCreate(opts: {
@@ -101,15 +90,14 @@ export async function subscriptionCreate(opts: {
   productId: string
   period: string
 }): Promise<void> {
-  const result = await ascFetch<{ data: { id: string } }>("/v1/subscriptions", {
-    method: "POST",
+  const result = await subscriptionsCreateInstance({
     body: {
       data: {
         type: "subscriptions",
         attributes: {
           name: opts.name,
           productId: opts.productId,
-          subscriptionPeriod: opts.period,
+          subscriptionPeriod: opts.period as never,
         },
         relationships: {
           group: { data: { type: "subscriptionGroups", id: opts.groupId } },
@@ -117,7 +105,8 @@ export async function subscriptionCreate(opts: {
       },
     },
   })
-  printSuccess(`Created subscription: ${result.data.data.id} (${opts.productId})`)
+  const data = throwOnError(result)
+  printSuccess(`Created subscription: ${data.data.id} (${opts.productId})`)
 }
 
 export async function subscriptionPricesList(opts: {
@@ -125,20 +114,23 @@ export async function subscriptionPricesList(opts: {
   territory?: string
   output?: string
 }): Promise<void> {
-  const params: Record<string, string> = {
-    "fields[subscriptionPrices]": "startDate,territory",
-    include: "subscriptionPricePoint",
+  const query: Record<string, unknown> = {
+    "fields[subscriptionPrices]": ["startDate", "territory"],
+    include: ["subscriptionPricePoint"],
   }
-  if (opts.territory) params["filter[territory]"] = opts.territory
-  const items = await ascFetchAll<{
-    id: string
-    attributes: { startDate?: string; territory?: unknown }
-  }>(`/v1/subscriptions/${opts.subId}/prices`, { params })
+  if (opts.territory) query["filter[territory]"] = [opts.territory]
+
+  const result = await subscriptionsPricesGetToManyRelated({
+    path: { id: opts.subId },
+    query: query as never,
+  })
+  const data = throwOnError(result)
+  const items = data.data
   const fmt = detectFormat(opts.output)
   if (fmt === "json") { printJSON(items); return }
   printTable(
     ["Price ID", "Territory", "Start Date"],
-    items.map(p => [p.id, String(p.attributes.territory ?? "-"), p.attributes.startDate ?? "ongoing"]),
+    items.map(p => [p.id, String((p.attributes as Record<string, unknown>)?.territory ?? "-"), (p.attributes as Record<string, unknown>)?.startDate as string ?? "ongoing"]),
     `Subscription Prices (${items.length})`,
   )
 }

package/src/commands/testflight.ts

@@ -1,17 +1,28 @@
 import * as p from "@clack/prompts"
-import { ascFetch, ascFetchAll } from "../api/client.ts"
-import type { BetaGroup, BetaTester } from "../api/types.ts"
-import { detectFormat, formatDate, printJSON, printSuccess, printTable, truncate } from "../utils/output.ts"
+import {
+  appsBetaGroupsGetToManyRelated,
+  betaGroupsGetCollection,
+  betaGroupsBetaTestersGetToManyRelated,
+  betaTestersCreateInstance,
+  betaGroupsBetaTestersDeleteToManyRelationship,
+} from "../api/generated/sdk.gen.ts"
+import { throwOnError } from "../api/client.ts"
+import { detectFormat, formatDate, printJSON, printSuccess, printTable } from "../utils/output.ts"
 
 export async function testflightGroupsList(opts: {
   appId?: string
   output?: string
 } = {}): Promise<void> {
-  let groups: BetaGroup[]
+  let groups: Array<{ id: string; attributes?: { name?: string; isInternalGroup?: boolean; publicLink?: string | null } }>
+
   if (opts.appId) {
-    groups = await ascFetchAll<BetaGroup>(`/v1/apps/${opts.appId}/betaGroups`)
+    const result = await appsBetaGroupsGetToManyRelated({ path: { id: opts.appId } })
+    const data = throwOnError(result)
+    groups = data.data
   } else {
-    groups = await ascFetchAll<BetaGroup>("/v1/betaGroups")
+    const result = await betaGroupsGetCollection()
+    const data = throwOnError(result)
+    groups = data.data
   }
 
   const fmt = detectFormat(opts.output)
@@ -24,9 +35,9 @@ export async function testflightGroupsList(opts: {
     ["ID", "Name", "Internal", "Public Link"],
     groups.map((g) => [
       g.id,
-      g.attributes.name,
-      g.attributes.isInternalGroup ? "yes" : "no",
-      g.attributes.publicLink ?? "-",
+      g.attributes?.name ?? "-",
+      g.attributes?.isInternalGroup ? "yes" : "no",
+      g.attributes?.publicLink ?? "-",
     ]),
     `Beta Groups (${groups.length})`,
   )
@@ -36,12 +47,12 @@ export async function testflightTestersList(opts: {
   groupId: string
   output?: string
 }): Promise<void> {
-  const testers = await ascFetchAll<BetaTester>(
-    `/v1/betaGroups/${opts.groupId}/betaTesters`,
-    {
-      params: { "fields[betaTesters]": "firstName,lastName,email,inviteType,state" },
-    },
-  )
+  const result = await betaGroupsBetaTestersGetToManyRelated({
+    path: { id: opts.groupId },
+    query: { "fields[betaTesters]": ["firstName", "lastName", "email", "inviteType", "state"] },
+  })
+  const data = throwOnError(result)
+  const testers = data.data
 
   const fmt = detectFormat(opts.output)
   if (fmt === "json") {
@@ -53,9 +64,9 @@ export async function testflightTestersList(opts: {
     ["ID", "Name", "Email", "State"],
     testers.map((t) => [
       t.id,
-      [t.attributes.firstName, t.attributes.lastName].filter(Boolean).join(" ") || "-",
-      t.attributes.email,
-      t.attributes.state ?? "-",
+      [t.attributes?.firstName, t.attributes?.lastName].filter(Boolean).join(" ") || "-",
+      t.attributes?.email ?? "-",
+      t.attributes?.state ?? "-",
     ]),
     `Testers (${testers.length})`,
   )
@@ -75,8 +86,7 @@ export async function testflightTestersAdd(opts: {
   }
 
   // Create tester + add to group
-  const res = await ascFetch<BetaTester>("/v1/betaTesters", {
-    method: "POST",
+  const result = await betaTestersCreateInstance({
     body: {
       data: {
         type: "betaTesters",
@@ -93,15 +103,16 @@ export async function testflightTestersAdd(opts: {
       },
     },
   })
-  printSuccess(`Tester ${email} added (ID: ${res.data.id})`)
+  const data = throwOnError(result)
+  printSuccess(`Tester ${email} added (ID: ${data.data.id})`)
 }
 
 export async function testflightTestersRemove(opts: {
   groupId: string
   testerId: string
 }): Promise<void> {
-  await ascFetch(`/v1/betaGroups/${opts.groupId}/relationships/betaTesters`, {
-    method: "DELETE",
+  await betaGroupsBetaTestersDeleteToManyRelationship({
+    path: { id: opts.groupId },
     body: {
       data: [{ type: "betaTesters", id: opts.testerId }],
     },