diff options
Diffstat (limited to 'packages/cloud/core/src')
20 files changed, 0 insertions, 913 deletions
diff --git a/packages/cloud/core/src/account.ts b/packages/cloud/core/src/account.ts deleted file mode 100644 index cb123e048..000000000 --- a/packages/cloud/core/src/account.ts +++ /dev/null @@ -1,67 +0,0 @@ -import { z } from "zod" -import { and, eq, getTableColumns, isNull } from "drizzle-orm" -import { fn } from "./util/fn" -import { Database } from "./drizzle" -import { Identifier } from "./identifier" -import { AccountTable } from "./schema/account.sql" -import { Actor } from "./actor" -import { WorkspaceTable } from "./schema/workspace.sql" -import { UserTable } from "./schema/user.sql" - -export namespace Account { - export const create = fn( - z.object({ - email: z.string().email(), - id: z.string().optional(), - }), - async (input) => - Database.transaction(async (tx) => { - const id = input.id ?? Identifier.create("account") - await tx.insert(AccountTable).values({ - id, - email: input.email, - }) - return id - }), - ) - - export const fromID = fn(z.string(), async (id) => - Database.transaction(async (tx) => { - return tx - .select() - .from(AccountTable) - .where(eq(AccountTable.id, id)) - .execute() - .then((rows) => rows[0]) - }), - ) - - export const fromEmail = fn(z.string().email(), async (email) => - Database.transaction(async (tx) => { - return tx - .select() - .from(AccountTable) - .where(eq(AccountTable.email, email)) - .execute() - .then((rows) => rows[0]) - }), - ) - - export const workspaces = async () => { - const actor = Actor.assert("account") - return Database.transaction(async (tx) => - tx - .select(getTableColumns(WorkspaceTable)) - .from(WorkspaceTable) - .innerJoin(UserTable, eq(UserTable.workspaceID, WorkspaceTable.id)) - .where( - and( - eq(UserTable.email, actor.properties.email), - isNull(UserTable.timeDeleted), - isNull(WorkspaceTable.timeDeleted), - ), - ) - .execute(), - ) - } -} diff --git a/packages/cloud/core/src/actor.ts b/packages/cloud/core/src/actor.ts deleted file mode 100644 index 0d13f7216..000000000 --- a/packages/cloud/core/src/actor.ts +++ /dev/null @@ -1,74 +0,0 @@ -import { Context } from "./context" -import { Log } from "./util/log" - -export namespace Actor { - interface Account { - type: "account" - properties: { - accountID: string - email: string - } - } - - interface Public { - type: "public" - properties: {} - } - - interface User { - type: "user" - properties: { - userID: string - workspaceID: string - } - } - - interface System { - type: "system" - properties: { - workspaceID: string - } - } - - export type Info = Account | Public | User | System - - const ctx = Context.create<Info>() - export const use = ctx.use - - const log = Log.create().tag("namespace", "actor") - - export function provide<R, T extends Info["type"]>( - type: T, - properties: Extract<Info, { type: T }>["properties"], - cb: () => R, - ) { - return ctx.provide( - { - type, - properties, - } as any, - () => { - return Log.provide({ ...properties }, () => { - log.info("provided") - return cb() - }) - }, - ) - } - - export function assert<T extends Info["type"]>(type: T) { - const actor = use() - if (actor.type !== type) { - throw new Error(`Expected actor type ${type}, got ${actor.type}`) - } - return actor as Extract<Info, { type: T }> - } - - export function workspace() { - const actor = use() - if ("workspaceID" in actor.properties) { - return actor.properties.workspaceID - } - throw new Error(`actor of type "${actor.type}" is not associated with a workspace`) - } -} diff --git a/packages/cloud/core/src/billing.ts b/packages/cloud/core/src/billing.ts deleted file mode 100644 index 2254adc79..000000000 --- a/packages/cloud/core/src/billing.ts +++ /dev/null @@ -1,244 +0,0 @@ -import { Stripe } from "stripe" -import { Database, eq, sql } from "./drizzle" -import { BillingTable, PaymentTable, UsageTable } from "./schema/billing.sql" -import { Actor } from "./actor" -import { fn } from "./util/fn" -import { z } from "zod" -import { User } from "./user" -import { Resource } from "@opencode/cloud-resource" -import { Identifier } from "./identifier" -import { centsToMicroCents } from "./util/price" - -export namespace Billing { - export const CHARGE_AMOUNT = 2000 // $20 - export const CHARGE_FEE = 123 // Stripe fee 4.4% + $0.30 - export const CHARGE_THRESHOLD = 500 // $5 - export const stripe = () => - new Stripe(Resource.STRIPE_SECRET_KEY.value, { - apiVersion: "2025-03-31.basil", - }) - - export const get = async () => { - return Database.use(async (tx) => - tx - .select({ - customerID: BillingTable.customerID, - paymentMethodID: BillingTable.paymentMethodID, - paymentMethodLast4: BillingTable.paymentMethodLast4, - balance: BillingTable.balance, - reload: BillingTable.reload, - monthlyLimit: BillingTable.monthlyLimit, - monthlyUsage: BillingTable.monthlyUsage, - timeMonthlyUsageUpdated: BillingTable.timeMonthlyUsageUpdated, - reloadError: BillingTable.reloadError, - timeReloadError: BillingTable.timeReloadError, - }) - .from(BillingTable) - .where(eq(BillingTable.workspaceID, Actor.workspace())) - .then((r) => r[0]), - ) - } - - export const payments = async () => { - return await Database.use((tx) => - tx - .select() - .from(PaymentTable) - .where(eq(PaymentTable.workspaceID, Actor.workspace())) - .orderBy(sql`${PaymentTable.timeCreated} DESC`) - .limit(100), - ) - } - - export const usages = async () => { - return await Database.use((tx) => - tx - .select() - .from(UsageTable) - .where(eq(UsageTable.workspaceID, Actor.workspace())) - .orderBy(sql`${UsageTable.timeCreated} DESC`) - .limit(100), - ) - } - - export const reload = async () => { - const { customerID, paymentMethodID } = await Database.use((tx) => - tx - .select({ - customerID: BillingTable.customerID, - paymentMethodID: BillingTable.paymentMethodID, - }) - .from(BillingTable) - .where(eq(BillingTable.workspaceID, Actor.workspace())) - .then((rows) => rows[0]), - ) - const paymentID = Identifier.create("payment") - let charge - try { - charge = await Billing.stripe().paymentIntents.create( - { - amount: Billing.CHARGE_AMOUNT + Billing.CHARGE_FEE, - currency: "usd", - customer: customerID!, - payment_method: paymentMethodID!, - off_session: true, - confirm: true, - }, - { idempotencyKey: paymentID }, - ) - - if (charge.status !== "succeeded") throw new Error(charge.last_payment_error?.message) - } catch (e: any) { - await Database.use((tx) => - tx - .update(BillingTable) - .set({ - reloadError: e.message ?? "Payment failed.", - timeReloadError: sql`now()`, - }) - .where(eq(BillingTable.workspaceID, Actor.workspace())), - ) - return - } - - await Database.transaction(async (tx) => { - await tx - .update(BillingTable) - .set({ - balance: sql`${BillingTable.balance} + ${centsToMicroCents(CHARGE_AMOUNT)}`, - reloadError: null, - timeReloadError: null, - }) - .where(eq(BillingTable.workspaceID, Actor.workspace())) - await tx.insert(PaymentTable).values({ - workspaceID: Actor.workspace(), - id: paymentID, - amount: centsToMicroCents(CHARGE_AMOUNT), - paymentID: charge.id, - customerID, - }) - }) - } - - export const disableReload = async () => { - return await Database.use((tx) => - tx - .update(BillingTable) - .set({ - reload: false, - }) - .where(eq(BillingTable.workspaceID, Actor.workspace())), - ) - } - - export const setMonthlyLimit = fn(z.number(), async (input) => { - return await Database.use((tx) => - tx - .update(BillingTable) - .set({ - monthlyLimit: input, - }) - .where(eq(BillingTable.workspaceID, Actor.workspace())), - ) - }) - - export const generateCheckoutUrl = fn( - z.object({ - successUrl: z.string(), - cancelUrl: z.string(), - }), - async (input) => { - const account = Actor.assert("user") - const { successUrl, cancelUrl } = input - - const user = await User.fromID(account.properties.userID) - const customer = await Billing.get() - const session = await Billing.stripe().checkout.sessions.create({ - mode: "payment", - line_items: [ - { - price_data: { - currency: "usd", - product_data: { - name: "opencode credits", - }, - unit_amount: CHARGE_AMOUNT, - }, - quantity: 1, - }, - { - price_data: { - currency: "usd", - product_data: { - name: "processing fee", - }, - unit_amount: CHARGE_FEE, - }, - quantity: 1, - }, - ], - payment_intent_data: { - setup_future_usage: "on_session", - }, - ...(customer.customerID - ? { - customer: customer.customerID, - } - : { - customer_email: user.email, - customer_creation: "always", - }), - metadata: { - workspaceID: Actor.workspace(), - }, - currency: "usd", - payment_method_types: ["card"], - payment_method_data: { - allow_redisplay: "always", - }, - success_url: successUrl, - cancel_url: cancelUrl, - }) - - return session.url - }, - ) - - export const generateSessionUrl = fn( - z.object({ - returnUrl: z.string(), - }), - async (input) => { - const { returnUrl } = input - - const customer = await Billing.get() - if (!customer?.customerID) { - throw new Error("No stripe customer ID") - } - - const session = await Billing.stripe().billingPortal.sessions.create({ - customer: customer.customerID, - return_url: returnUrl, - }) - - return session.url - }, - ) - - export const generateReceiptUrl = fn( - z.object({ - paymentID: z.string(), - }), - async (input) => { - const { paymentID } = input - - const intent = await Billing.stripe().paymentIntents.retrieve(paymentID) - if (!intent.latest_charge) throw new Error("No charge found") - - const charge = await Billing.stripe().charges.retrieve(intent.latest_charge as string) - if (!charge.receipt_url) throw new Error("No receipt URL found") - - return charge.receipt_url - }, - ) -} diff --git a/packages/cloud/core/src/context.ts b/packages/cloud/core/src/context.ts deleted file mode 100644 index c2ca6a313..000000000 --- a/packages/cloud/core/src/context.ts +++ /dev/null @@ -1,21 +0,0 @@ -import { AsyncLocalStorage } from "node:async_hooks" - -export namespace Context { - export class NotFound extends Error {} - - export function create<T>() { - const storage = new AsyncLocalStorage<T>() - return { - use() { - const result = storage.getStore() - if (!result) { - throw new NotFound() - } - return result - }, - provide<R>(value: T, fn: () => R) { - return storage.run<R>(value, fn) - }, - } - } -} diff --git a/packages/cloud/core/src/drizzle/index.ts b/packages/cloud/core/src/drizzle/index.ts deleted file mode 100644 index 806037996..000000000 --- a/packages/cloud/core/src/drizzle/index.ts +++ /dev/null @@ -1,86 +0,0 @@ -import { drizzle } from "drizzle-orm/planetscale-serverless" -import { Resource } from "@opencode/cloud-resource" -export * from "drizzle-orm" -import { Client } from "@planetscale/database" - -import { MySqlTransaction, type MySqlTransactionConfig } from "drizzle-orm/mysql-core" -import type { ExtractTablesWithRelations } from "drizzle-orm" -import type { PlanetScalePreparedQueryHKT, PlanetscaleQueryResultHKT } from "drizzle-orm/planetscale-serverless" -import { Context } from "../context" -import { memo } from "../util/memo" - -export namespace Database { - export type Transaction = MySqlTransaction< - PlanetscaleQueryResultHKT, - PlanetScalePreparedQueryHKT, - Record<string, never>, - ExtractTablesWithRelations<Record<string, never>> - > - - const client = memo(() => { - const result = new Client({ - host: Resource.Database.host, - username: Resource.Database.username, - password: Resource.Database.password, - }) - const db = drizzle(result, {}) - return db - }) - - export type TxOrDb = Transaction | ReturnType<typeof client> - - const TransactionContext = Context.create<{ - tx: TxOrDb - effects: (() => void | Promise<void>)[] - }>() - - export async function use<T>(callback: (trx: TxOrDb) => Promise<T>) { - try { - const { tx } = TransactionContext.use() - return tx.transaction(callback) - } catch (err) { - if (err instanceof Context.NotFound) { - const effects: (() => void | Promise<void>)[] = [] - const result = await TransactionContext.provide( - { - effects, - tx: client(), - }, - () => callback(client()), - ) - await Promise.all(effects.map((x) => x())) - return result - } - throw err - } - } - export async function fn<Input, T>(callback: (input: Input, trx: TxOrDb) => Promise<T>) { - return (input: Input) => use(async (tx) => callback(input, tx)) - } - - export async function effect(effect: () => any | Promise<any>) { - try { - const { effects } = TransactionContext.use() - effects.push(effect) - } catch { - await effect() - } - } - - export async function transaction<T>(callback: (tx: TxOrDb) => Promise<T>, config?: MySqlTransactionConfig) { - try { - const { tx } = TransactionContext.use() - return callback(tx) - } catch (err) { - if (err instanceof Context.NotFound) { - const effects: (() => void | Promise<void>)[] = [] - const result = await client().transaction(async (tx) => { - return TransactionContext.provide({ tx, effects }, () => callback(tx)) - }, config) - await Promise.all(effects.map((x) => x())) - return result - } - throw err - } - } -} diff --git a/packages/cloud/core/src/drizzle/types.ts b/packages/cloud/core/src/drizzle/types.ts deleted file mode 100644 index f16ad5a8a..000000000 --- a/packages/cloud/core/src/drizzle/types.ts +++ /dev/null @@ -1,33 +0,0 @@ -import { sql } from "drizzle-orm" -import { bigint, timestamp, varchar } from "drizzle-orm/mysql-core" - -export const ulid = (name: string) => varchar(name, { length: 30 }) - -export const workspaceColumns = { - get id() { - return ulid("id").notNull() - }, - get workspaceID() { - return ulid("workspace_id").notNull() - }, -} - -export const id = () => ulid("id").notNull() - -export const utc = (name: string) => - timestamp(name, { - fsp: 3, - }) - -export const currency = (name: string) => - bigint(name, { - mode: "number", - }) - -export const timestamps = { - timeCreated: utc("time_created").notNull().defaultNow(), - timeUpdated: utc("time_updated") - .notNull() - .default(sql`CURRENT_TIMESTAMP(3) ON UPDATE CURRENT_TIMESTAMP(3)`), - timeDeleted: utc("time_deleted"), -} diff --git a/packages/cloud/core/src/identifier.ts b/packages/cloud/core/src/identifier.ts deleted file mode 100644 index f8e73852e..000000000 --- a/packages/cloud/core/src/identifier.ts +++ /dev/null @@ -1,26 +0,0 @@ -import { ulid } from "ulid" -import { z } from "zod" - -export namespace Identifier { - const prefixes = { - account: "acc", - billing: "bil", - key: "key", - payment: "pay", - usage: "usg", - user: "usr", - workspace: "wrk", - } as const - - export function create(prefix: keyof typeof prefixes, given?: string): string { - if (given) { - if (given.startsWith(prefixes[prefix])) return given - throw new Error(`ID ${given} does not start with ${prefixes[prefix]}`) - } - return [prefixes[prefix], ulid()].join("_") - } - - export function schema(prefix: keyof typeof prefixes) { - return z.string().startsWith(prefixes[prefix]) - } -} diff --git a/packages/cloud/core/src/key.ts b/packages/cloud/core/src/key.ts deleted file mode 100644 index 28643a521..000000000 --- a/packages/cloud/core/src/key.ts +++ /dev/null @@ -1,75 +0,0 @@ -import { z } from "zod" -import { fn } from "./util/fn" -import { Actor } from "./actor" -import { and, Database, eq, isNull, sql } from "./drizzle" -import { Identifier } from "./identifier" -import { KeyTable } from "./schema/key.sql" - -export namespace Key { - export const list = async () => { - const workspace = Actor.workspace() - const keys = await Database.use((tx) => - tx - .select() - .from(KeyTable) - .where(and(eq(KeyTable.workspaceID, workspace), isNull(KeyTable.timeDeleted))) - .orderBy(sql`${KeyTable.timeCreated} DESC`), - ) - return keys - } - - export const create = fn(z.object({ name: z.string().min(1).max(255) }), async (input) => { - const workspaceID = Actor.workspace() - const { name } = input - - // Generate secret key: sk- + 64 random characters (upper, lower, numbers) - const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789" - let secretKey = "sk-" - const array = new Uint32Array(64) - crypto.getRandomValues(array) - for (let i = 0, l = array.length; i < l; i++) { - secretKey += chars[array[i] % chars.length] - } - const keyID = Identifier.create("key") - - await Database.use((tx) => - tx.insert(KeyTable).values({ - id: keyID, - workspaceID, - actor: Actor.use(), - name, - key: secretKey, - timeUsed: null, - }), - ).catch((e: any) => { - if (e.message.match(/Duplicate entry '.*' for key 'key.name'/)) - throw new Error("A key with this name already exists. Please choose a different name.") - throw e - }) - - return keyID - }) - - export const remove = fn(z.object({ id: z.string() }), async (input) => { - const workspace = Actor.workspace() - await Database.transaction(async (tx) => { - const row = await tx - .select({ - name: KeyTable.name, - }) - .from(KeyTable) - .where(and(eq(KeyTable.id, input.id), eq(KeyTable.workspaceID, workspace))) - .then((rows) => rows[0]) - if (!row) return - - await tx - .update(KeyTable) - .set({ - timeDeleted: sql`now()`, - oldName: row.name, - name: input.id, // Use the key ID as the name - }) - .where(and(eq(KeyTable.id, input.id), eq(KeyTable.workspaceID, workspace))) - }) - }) -} diff --git a/packages/cloud/core/src/schema/account.sql.ts b/packages/cloud/core/src/schema/account.sql.ts deleted file mode 100644 index 4d9937114..000000000 --- a/packages/cloud/core/src/schema/account.sql.ts +++ /dev/null @@ -1,12 +0,0 @@ -import { mysqlTable, uniqueIndex, varchar } from "drizzle-orm/mysql-core" -import { id, timestamps } from "../drizzle/types" - -export const AccountTable = mysqlTable( - "account", - { - id: id(), - ...timestamps, - email: varchar("email", { length: 255 }).notNull(), - }, - (table) => [uniqueIndex("email").on(table.email)], -) diff --git a/packages/cloud/core/src/schema/billing.sql.ts b/packages/cloud/core/src/schema/billing.sql.ts deleted file mode 100644 index 5bec4e900..000000000 --- a/packages/cloud/core/src/schema/billing.sql.ts +++ /dev/null @@ -1,53 +0,0 @@ -import { bigint, boolean, int, mysqlTable, uniqueIndex, varchar } from "drizzle-orm/mysql-core" -import { timestamps, utc, workspaceColumns } from "../drizzle/types" -import { workspaceIndexes } from "./workspace.sql" - -export const BillingTable = mysqlTable( - "billing", - { - ...workspaceColumns, - ...timestamps, - customerID: varchar("customer_id", { length: 255 }), - paymentMethodID: varchar("payment_method_id", { length: 255 }), - paymentMethodLast4: varchar("payment_method_last4", { length: 4 }), - balance: bigint("balance", { mode: "number" }).notNull(), - monthlyLimit: int("monthly_limit"), - monthlyUsage: bigint("monthly_usage", { mode: "number" }), - timeMonthlyUsageUpdated: utc("time_monthly_usage_updated"), - reload: boolean("reload"), - reloadError: varchar("reload_error", { length: 255 }), - timeReloadError: utc("time_reload_error"), - timeReloadLockedTill: utc("time_reload_locked_till"), - }, - (table) => [...workspaceIndexes(table), uniqueIndex("global_customer_id").on(table.customerID)], -) - -export const PaymentTable = mysqlTable( - "payment", - { - ...workspaceColumns, - ...timestamps, - customerID: varchar("customer_id", { length: 255 }), - paymentID: varchar("payment_id", { length: 255 }), - amount: bigint("amount", { mode: "number" }).notNull(), - }, - (table) => [...workspaceIndexes(table)], -) - -export const UsageTable = mysqlTable( - "usage", - { - ...workspaceColumns, - ...timestamps, - model: varchar("model", { length: 255 }).notNull(), - provider: varchar("provider", { length: 255 }).notNull(), - inputTokens: int("input_tokens").notNull(), - outputTokens: int("output_tokens").notNull(), - reasoningTokens: int("reasoning_tokens"), - cacheReadTokens: int("cache_read_tokens"), - cacheWrite5mTokens: int("cache_write_5m_tokens"), - cacheWrite1hTokens: int("cache_write_1h_tokens"), - cost: bigint("cost", { mode: "number" }).notNull(), - }, - (table) => [...workspaceIndexes(table)], -) diff --git a/packages/cloud/core/src/schema/key.sql.ts b/packages/cloud/core/src/schema/key.sql.ts deleted file mode 100644 index 98b99c788..000000000 --- a/packages/cloud/core/src/schema/key.sql.ts +++ /dev/null @@ -1,22 +0,0 @@ -import { mysqlTable, varchar, uniqueIndex, json } from "drizzle-orm/mysql-core" -import { timestamps, utc, workspaceColumns } from "../drizzle/types" -import { workspaceIndexes } from "./workspace.sql" -import { Actor } from "../actor" - -export const KeyTable = mysqlTable( - "key", - { - ...workspaceColumns, - ...timestamps, - actor: json("actor").$type<Actor.Info>(), - name: varchar("name", { length: 255 }).notNull(), - oldName: varchar("old_name", { length: 255 }), - key: varchar("key", { length: 255 }).notNull(), - timeUsed: utc("time_used"), - }, - (table) => [ - ...workspaceIndexes(table), - uniqueIndex("global_key").on(table.key), - uniqueIndex("name").on(table.workspaceID, table.name), - ], -) diff --git a/packages/cloud/core/src/schema/user.sql.ts b/packages/cloud/core/src/schema/user.sql.ts deleted file mode 100644 index 00c372d1a..000000000 --- a/packages/cloud/core/src/schema/user.sql.ts +++ /dev/null @@ -1,16 +0,0 @@ -import { text, mysqlTable, uniqueIndex, varchar, int } from "drizzle-orm/mysql-core" -import { timestamps, utc, workspaceColumns } from "../drizzle/types" -import { workspaceIndexes } from "./workspace.sql" - -export const UserTable = mysqlTable( - "user", - { - ...workspaceColumns, - ...timestamps, - email: varchar("email", { length: 255 }).notNull(), - name: varchar("name", { length: 255 }).notNull(), - timeSeen: utc("time_seen"), - color: int("color"), - }, - (table) => [...workspaceIndexes(table), uniqueIndex("user_email").on(table.workspaceID, table.email)], -) diff --git a/packages/cloud/core/src/schema/workspace.sql.ts b/packages/cloud/core/src/schema/workspace.sql.ts deleted file mode 100644 index 979255428..000000000 --- a/packages/cloud/core/src/schema/workspace.sql.ts +++ /dev/null @@ -1,21 +0,0 @@ -import { primaryKey, mysqlTable, uniqueIndex, varchar } from "drizzle-orm/mysql-core" -import { timestamps, ulid } from "../drizzle/types" - -export const WorkspaceTable = mysqlTable( - "workspace", - { - id: ulid("id").notNull().primaryKey(), - slug: varchar("slug", { length: 255 }), - name: varchar("name", { length: 255 }), - ...timestamps, - }, - (table) => [uniqueIndex("slug").on(table.slug)], -) - -export function workspaceIndexes(table: any) { - return [ - primaryKey({ - columns: [table.workspaceID, table.id], - }), - ] -} diff --git a/packages/cloud/core/src/user.ts b/packages/cloud/core/src/user.ts deleted file mode 100644 index 7914926ff..000000000 --- a/packages/cloud/core/src/user.ts +++ /dev/null @@ -1,18 +0,0 @@ -import { z } from "zod" -import { eq } from "drizzle-orm" -import { fn } from "./util/fn" -import { Database } from "./drizzle" -import { UserTable } from "./schema/user.sql" - -export namespace User { - export const fromID = fn(z.string(), async (id) => - Database.transaction(async (tx) => { - return tx - .select() - .from(UserTable) - .where(eq(UserTable.id, id)) - .execute() - .then((rows) => rows[0]) - }), - ) -} diff --git a/packages/cloud/core/src/util/env.cloudflare.ts b/packages/cloud/core/src/util/env.cloudflare.ts deleted file mode 100644 index e69de29bb..000000000 --- a/packages/cloud/core/src/util/env.cloudflare.ts +++ /dev/null diff --git a/packages/cloud/core/src/util/fn.ts b/packages/cloud/core/src/util/fn.ts deleted file mode 100644 index 9efe4622f..000000000 --- a/packages/cloud/core/src/util/fn.ts +++ /dev/null @@ -1,11 +0,0 @@ -import { z } from "zod" - -export function fn<T extends z.ZodType, Result>(schema: T, cb: (input: z.infer<T>) => Result) { - const result = (input: z.infer<T>) => { - const parsed = schema.parse(input) - return cb(parsed) - } - result.force = (input: z.infer<T>) => cb(input) - result.schema = schema - return result -} diff --git a/packages/cloud/core/src/util/log.ts b/packages/cloud/core/src/util/log.ts deleted file mode 100644 index 4f2d25c13..000000000 --- a/packages/cloud/core/src/util/log.ts +++ /dev/null @@ -1,55 +0,0 @@ -import { Context } from "../context" - -export namespace Log { - const ctx = Context.create<{ - tags: Record<string, any> - }>() - - export function create(tags?: Record<string, any>) { - tags = tags || {} - - const result = { - info(message?: any, extra?: Record<string, any>) { - const prefix = Object.entries({ - ...use().tags, - ...tags, - ...extra, - }) - .map(([key, value]) => `${key}=${value}`) - .join(" ") - console.log(prefix, message) - return result - }, - tag(key: string, value: string) { - if (tags) tags[key] = value - return result - }, - clone() { - return Log.create({ ...tags }) - }, - } - - return result - } - - export function provide<R>(tags: Record<string, any>, cb: () => R) { - const existing = use() - return ctx.provide( - { - tags: { - ...existing.tags, - ...tags, - }, - }, - cb, - ) - } - - function use() { - try { - return ctx.use() - } catch (e) { - return { tags: {} } - } - } -} diff --git a/packages/cloud/core/src/util/memo.ts b/packages/cloud/core/src/util/memo.ts deleted file mode 100644 index 49043010f..000000000 --- a/packages/cloud/core/src/util/memo.ts +++ /dev/null @@ -1,18 +0,0 @@ -export function memo<T>(fn: () => T, cleanup?: (input: T) => Promise<void>) { - let value: T | undefined - let loaded = false - - const result = (): T => { - if (loaded) return value as T - loaded = true - value = fn() - return value as T - } - result.reset = async () => { - if (cleanup && value) await cleanup(value) - loaded = false - value = undefined - } - - return result -} diff --git a/packages/cloud/core/src/util/price.ts b/packages/cloud/core/src/util/price.ts deleted file mode 100644 index abdbca032..000000000 --- a/packages/cloud/core/src/util/price.ts +++ /dev/null @@ -1,3 +0,0 @@ -export function centsToMicroCents(amount: number) { - return Math.round(amount * 1000000) -} diff --git a/packages/cloud/core/src/workspace.ts b/packages/cloud/core/src/workspace.ts deleted file mode 100644 index a9fb923d6..000000000 --- a/packages/cloud/core/src/workspace.ts +++ /dev/null @@ -1,58 +0,0 @@ -import { z } from "zod" -import { fn } from "./util/fn" -import { centsToMicroCents } from "./util/price" -import { Actor } from "./actor" -import { Database, eq } from "./drizzle" -import { Identifier } from "./identifier" -import { UserTable } from "./schema/user.sql" -import { BillingTable } from "./schema/billing.sql" -import { WorkspaceTable } from "./schema/workspace.sql" -import { Key } from "./key" - -export namespace Workspace { - export const create = fn(z.void(), async () => { - const account = Actor.assert("account") - const workspaceID = Identifier.create("workspace") - await Database.transaction(async (tx) => { - await tx.insert(WorkspaceTable).values({ - id: workspaceID, - }) - await tx.insert(UserTable).values({ - workspaceID, - id: Identifier.create("user"), - email: account.properties.email, - name: "", - }) - await tx.insert(BillingTable).values({ - workspaceID, - id: Identifier.create("billing"), - balance: 0, - }) - }) - await Actor.provide( - "system", - { - workspaceID, - }, - async () => { - await Key.create({ name: "Default API Key" }) - }, - ) - return workspaceID - }) - - export async function list() { - const account = Actor.assert("account") - return Database.use(async (tx) => { - return tx - .select({ - id: WorkspaceTable.id, - slug: WorkspaceTable.slug, - name: WorkspaceTable.name, - }) - .from(UserTable) - .innerJoin(WorkspaceTable, eq(UserTable.workspaceID, WorkspaceTable.id)) - .where(eq(UserTable.email, account.properties.email)) - }) - } -} |