npm - @tscircuit/cli - Versions diffs - 0.0.116 → 0.0.119 - Mend

@tscircuit/cli 0.0.116 → 0.0.119

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (58) hide show

package/dev-server-api/routes/api/package_info/create.ts CHANGED Viewed

@@ -4,25 +4,23 @@ import { z } from "zod"
 export default withWinterSpec({
   methods: ["POST"],
   jsonBody: z.object({
-    package_name: z.string()
+    package_name: z.string(),
   }),
   jsonResponse: z.object({
     package_info: z.object({
-      name: z.string()
-    })
+      name: z.string(),
+    }),
   }),
   auth: "none",
 })(async (req, ctx) => {
   const package_name = req.jsonBody.package_name
-  const package_info = await ctx.db
-    .insertInto("package_info")
-    .values({
-      name: package_name
-    })
-    .returningAll()
-    .executeTakeFirstOrThrow()
+  const package_info = await ctx.db.put("package_info", {
+    package_info_id: 1,
+    name: package_name,
+  })
   return ctx.json({
-    package_info
+    package_info,
   })
 })

package/dev-server-api/routes/api/package_info/get.ts CHANGED Viewed

@@ -1,18 +1,15 @@
-import { export_package_info } from "src/lib/zod/export_package_info"
+import { PackageInfoSchema } from "src/db/schema"
 import { withWinterSpec } from "src/with-winter-spec"
 import { z } from "zod"
 export default withWinterSpec({
   methods: ["GET"],
   jsonResponse: z.object({
-    package_info: export_package_info
+    package_info: PackageInfoSchema,
   }),
   auth: "none",
 })(async (req, ctx) => {
-  const package_info = await ctx.db
-    .selectFrom("package_info")
-    .select("name")
-    .executeTakeFirstOrThrow()
+  const package_info = await ctx.db.get("package_info", 1)
-  return ctx.json({  package_info  })
-})
+  return ctx.json({ package_info: package_info! })
+})

package/dev-server-api/routes/index.ts ADDED Viewed

@@ -0,0 +1,16 @@
+import { withWinterSpec } from "../src/with-winter-spec"
+import { z } from "zod"
+export default withWinterSpec({
+  methods: ["GET"],
+  auth: "none",
+})(async (req, ctx) => {
+  return new Response(
+    `<html><body>This is the dev server API <a href="/api/db/download">view database</a></body></html>`,
+    {
+      headers: {
+        "content-type": "text/html",
+      },
+    }
+  )
+})

package/dev-server-api/server.ts CHANGED Viewed

@@ -6,7 +6,7 @@ const serverFetch = await createFetchHandlerFromDir(
   join(import.meta.dir, "./routes")
 )
-console.log("starting dev-server-api on localhost:3021")
+console.log("starting dev-server-api on http://localhost:3021")
 Bun.serve({
   fetch: (bunReq) => {
     const req = new EdgeRuntimeRequest(bunReq.url, {

package/dev-server-api/src/db/get-db.ts CHANGED Viewed

@@ -1,117 +1,26 @@
 import { mkdirSync } from "fs"
-import { Kysely, SqliteDialect, sql, type Generated } from "kysely"
 import * as Path from "path"
-import { createSchema } from "./create-schema"
+import { ZodLevelDatabase } from "./zod-level-db"
-export interface PackageInfo {
-  name: string
-}
-export interface DevPackageExample {
-  dev_package_example_id: Generated<number>
-  tscircuit_soup: any
-  completed_edit_events: any
-  file_path: string
-  export_name: string
-  error: string | null
-  is_loading: 1 | 0
-  last_updated_at: string
-  soup_last_updated_at: string
-  edit_events_last_updated_at: string
-  edit_events_last_applied_at: string
-}
-export interface ExportRequest {
-  export_request_id: Generated<number>
-  example_file_path: string
-  export_parameters: string
-  export_name: string
-  is_complete: 1 | 0
-  has_error: 1 | 0
-  error?: string
-  created_at: string
-}
-export interface ExportFile {
-  export_file_id: Generated<number>
-  file_name: string
-  file_content: Buffer
-  export_request_id: number
-  created_at: string
-}
-interface KyselyDatabaseSchema {
-  dev_package_example: DevPackageExample
-  export_request: ExportRequest
-  export_file: ExportFile
-  package_info: PackageInfo
-}
-export type DbClient = Kysely<KyselyDatabaseSchema>
-// let globalDb: Database | undefined
-let globalDb: Kysely<KyselyDatabaseSchema> | undefined
+let globalDb: ZodLevelDatabase | undefined
 export const getDbFilePath = () =>
-  process.env.TSCI_DEV_SERVER_DB ?? "./.tscircuit/dev-server.sqlite"
+  process.env.TSCI_DEV_SERVER_DB ?? "./.tscircuit/devdb"
-export const getDb = async (): Promise<Kysely<KyselyDatabaseSchema>> => {
-  if (globalDb) return globalDb
-  const devServerDbPath = getDbFilePath()
-  mkdirSync(Path.dirname(devServerDbPath), { recursive: true })
-  // better-sqlite3 doesn't work in bun, so if we see we can use the bun
-  // alternative, attempt to use that instead
-  let dialect: any
-  if (typeof Bun !== "undefined") {
-    // console.log("Attempting to use bun-sqlite")
-    try {
-      const { BunSqliteDialect } = await import("kysely-bun-sqlite")
-      const { Database } = await import("bun:sqlite")
-      dialect = new BunSqliteDialect({
-        database: new Database(devServerDbPath, {
-          create: true,
-        }),
-      })
-    } catch (e) { }
-  }
-  if (!dialect) {
-    // console.log("Attempting to use better-sqlite3")
-    try {
-      const BetterSqlite3 = await import("better-sqlite3")
-      dialect = new SqliteDialect({
-        database: new BetterSqlite3.default(devServerDbPath),
-      })
-    } catch (e) { }
-  }
-  if (!dialect) {
-    throw new Error("Was not able to load sqlite dialect")
+export const getDb = async (): Promise<ZodLevelDatabase> => {
+  if (globalDb) {
+    return globalDb
   }
-  const db = new Kysely<KyselyDatabaseSchema>({
-    dialect,
-  })
+  const devServerDbPath = getDbFilePath()
-  await sql`pragma busy_timeout = 5000`.execute(db)
+  mkdirSync(devServerDbPath, { recursive: true })
-  const schemaExistsResult = await sql`
-    SELECT name
-    FROM sqlite_master
-    WHERE type='table' AND name IN ('dev_package_example', 'export_request', 'export_file', 'package_info')
-  `.execute(db)
+  const db = new ZodLevelDatabase(devServerDbPath)
-  // Check if the number of existing tables matches the number of required tables
-  if (schemaExistsResult.rows.length < 4) {
-    await createSchema(db)
-  }
+  db.open()
   globalDb = db
   return db
-}
+}

package/dev-server-api/src/db/schema.ts ADDED Viewed

@@ -0,0 +1,65 @@
+import { z } from "zod"
+// Helper function for nullable fields
+const nullableText = () => z.string().nullable().default(null)
+const id = () => z.any().pipe(z.number().int())
+// PackageInfo schema
+export const PackageInfoSchema = z.object({
+  package_info_id: id(),
+  name: z.string(),
+})
+// DevPackageExample schema
+export const DevPackageExampleSchema = z.object({
+  dev_package_example_id: id(),
+  file_path: z.string(),
+  export_name: nullableText(),
+  tscircuit_soup: z.any().nullable(), // Using any for JSON type
+  completed_edit_events: z.array(z.any()).default([]), // Using any for JSON type
+  error: nullableText(),
+  is_loading: z.boolean(),
+  soup_last_updated_at: nullableText(),
+  edit_events_last_updated_at: nullableText(),
+  edit_events_last_applied_at: nullableText(),
+  last_updated_at: nullableText(),
+})
+// ExportRequest schema
+export const ExportRequestSchema = z.object({
+  export_request_id: id(),
+  example_file_path: nullableText(),
+  export_parameters: z.any().nullable(), // Using any for JSON type
+  export_name: nullableText(),
+  is_complete: z.boolean(),
+  has_error: z.boolean(),
+  error: nullableText(),
+  created_at: nullableText(),
+})
+// ExportFile schema
+export const ExportFileSchema = z.object({
+  export_file_id: id(),
+  file_name: nullableText(),
+  file_content_base64: z.string().nullable(),
+  export_request_id: z.number().int().nullable(),
+  created_at: nullableText(),
+})
+// Combined DBSchema
+export const DBSchema = z.object({
+  package_info: PackageInfoSchema,
+  dev_package_example: DevPackageExampleSchema,
+  export_request: ExportRequestSchema,
+  export_file: ExportFileSchema,
+})
+// TypeScript type inference
+export type DBSchemaType = z.infer<typeof DBSchema>
+export type DBInputSchemaType = z.input<typeof DBSchema>
+// You can also export individual types if needed
+export type PackageInfo = z.infer<typeof PackageInfoSchema>
+export type DevPackageExample = z.infer<typeof DevPackageExampleSchema>
+export type ExportRequest = z.infer<typeof ExportRequestSchema>
+export type ExportFile = z.infer<typeof ExportFileSchema>

package/dev-server-api/src/db/zod-level-db.ts ADDED Viewed

@@ -0,0 +1,146 @@
+import { Level } from "level"
+import { z } from "zod"
+import { DBSchema, type DBSchemaType, type DBInputSchemaType } from "./schema"
+// Create a wrapper class for Level with Zod validation
+export class ZodLevelDatabase {
+  private db: Level<string, any>
+  constructor(location: string) {
+    this.db = new Level(location)
+  }
+  async open() {
+    return this.db.open()
+  }
+  async close() {
+    return this.db.close()
+  }
+  async get<K extends keyof DBSchemaType>(
+    collection: K,
+    id: string | number
+  ): Promise<DBSchemaType[K] | null> {
+    const key = `${collection}:${id}`
+    const data = await this.db.get(key)
+    return DBSchema.shape[collection].parse(JSON.parse(data)) as any
+  }
+  async put<K extends keyof DBSchemaType>(
+    collection: K,
+    value: DBInputSchemaType[K]
+  ): Promise<DBSchemaType[K]> {
+    const idkey = `${collection}_id`
+    const valueLoose: any = value
+    if (!valueLoose[idkey]) {
+      // generate an id using the "count" key
+      let count = await this.db
+        .get(`${collection}.count`, { valueEncoding: "json" })
+        .catch(() => 1)
+      ;(value as any)[idkey] = count
+      await this.db.put(`${collection}.count`, count + 1)
+    }
+    const key = `${collection}:${valueLoose[idkey]}`
+    const validatedData = DBSchema.shape[collection].parse(value)
+    await this.db.put(key, JSON.stringify(validatedData))
+    return validatedData as DBSchemaType[K]
+  }
+  async del<K extends keyof DBSchemaType>(
+    collection: K,
+    id: string
+  ): Promise<void> {
+    const key = `${collection}:${id}`
+    await this.db.del(key)
+  }
+  async find<K extends keyof DBSchemaType>(
+    collection: K,
+    partialObject: Partial<DBSchemaType[K]>
+  ): Promise<DBSchemaType[K] | null> {
+    const schema = DBSchema.shape[collection]
+    for await (const [key, value] of this.db.iterator({
+      gte: `${collection}:`,
+      lte: `${collection}:\uffff`,
+    })) {
+      try {
+        const parsedValue = schema.parse(JSON.parse(value))
+        if (this.matchesPartialObject(parsedValue, partialObject)) {
+          return parsedValue as any
+        }
+      } catch (error) {
+        console.error(`Error parsing value for key ${key}:`, error)
+      }
+    }
+    return null
+  }
+  async findOrThrow<K extends keyof DBSchemaType>(
+    collection: K,
+    partialObject: Partial<DBSchemaType[K]>
+  ): Promise<DBSchemaType[K]> {
+    const result = await this.find(collection, partialObject)
+    if (!result) {
+      throw new Error(
+        `No record in "${collection}" matches query ${JSON.stringify(
+          partialObject
+        )}`
+      )
+    }
+    return result
+  }
+  private matchesPartialObject<T>(
+    fullObject: T,
+    partialObject: Partial<T>
+  ): boolean {
+    for (const [key, value] of Object.entries(partialObject)) {
+      if (fullObject[key as keyof T] !== value) {
+        return false
+      }
+    }
+    return true
+  }
+  async dump(): Promise<DBSchemaType> {
+    // Serialize all data in the database
+    const dump: any = {}
+    for await (const [key, value] of this.db.iterator({})) {
+      const [collection, id] = key.split(":")
+      if (!dump[collection]) {
+        dump[collection] = {}
+      }
+      dump[collection][id] = JSON.parse(value)
+    }
+    return dump
+  }
+  async list<K extends keyof DBSchemaType>(
+    collection: K
+  ): Promise<DBSchemaType[K][]> {
+    const schema = DBSchema.shape[collection]
+    const results: DBSchemaType[K][] = []
+    for await (const [key, value] of this.db.iterator({
+      gte: `${collection}:`,
+      lte: `${collection}:\uffff`,
+    })) {
+      if (key.endsWith(".count")) continue
+      try {
+        const parsedValue = schema.parse(JSON.parse(value))
+        results.push(parsedValue as DBSchemaType[K])
+      } catch (error) {
+        console.error(`Error parsing value for key ${key}:`, error)
+      }
+    }
+    return results
+  }
+  async clear() {
+    return this.db.clear()
+  }
+}

package/dev-server-api/src/middlewares/with-db.ts CHANGED Viewed

@@ -1,14 +1,18 @@
 import type { Middleware } from "winterspec"
-import { getDb, type DbClient } from "../db/get-db"
+import { getDb } from "../db/get-db"
+import type { ZodLevelDatabase } from "src/db/zod-level-db"
 export const withDb: Middleware<
   {},
   {
-    db: DbClient
+    db: ZodLevelDatabase
   }
 > = async (req, ctx, next) => {
   if (!ctx.db) {
     ctx.db = await getDb()
   }
-  return next(req, ctx)
+  // await ctx.db.open()
+  const res = await next(req, ctx)
+  // await ctx.db.close()
+  return res
 }

package/dev-server-api/static-routes.ts CHANGED Viewed

@@ -2,6 +2,7 @@
 // import { WinterSpecRouteMap } from "@winterspec/types"
 const routeMap = {
+  "/api/db/download": (await import('routes/api/db/download.ts')).default,
   "/api/dev_package_examples/create": (await import('routes/api/dev_package_examples/create.ts')).default,
   "/api/dev_package_examples/get": (await import('routes/api/dev_package_examples/get.ts')).default,
   "/api/dev_package_examples/list": (await import('routes/api/dev_package_examples/list.ts')).default,
@@ -16,7 +17,8 @@ const routeMap = {
   "/api/health": (await import('routes/api/health.ts')).default,
   "/api/package_info/create": (await import('routes/api/package_info/create.ts')).default,
   "/api/package_info/get": (await import('routes/api/package_info/get.ts')).default,
-  "/health": (await import('routes/health.ts')).default
+  "/health": (await import('routes/health.ts')).default,
+  "/": (await import('routes/index.ts')).default
 }
 export default routeMap

package/dev-server-api/tests/fixtures/get-test-server.ts ADDED Viewed

@@ -0,0 +1,30 @@
+import { afterEach } from "bun:test"
+import defaultAxios from "redaxios"
+import { startServer } from "./start-server"
+import { tmpdir } from "node:os"
+interface TestFixture {
+  url: string
+  server: any
+  axios: typeof defaultAxios
+}
+export const getTestFixture = async (): Promise<TestFixture> => {
+  process.env.TSCI_DEV_SERVER_DB = tmpdir() + `/${Math.random()}` + "/devdb"
+  const port = 3001 + Math.floor(Math.random() * 999)
+  const server = startServer({ port })
+  const url = `http://localhost:${port}`
+  const axios = defaultAxios.create({
+    baseURL: url,
+  })
+  afterEach(() => {
+    server.stop()
+  })
+  return {
+    url,
+    server,
+    axios,
+  }
+}

package/dev-server-api/tests/fixtures/start-server.ts ADDED Viewed

@@ -0,0 +1,20 @@
+import { createFetchHandlerFromDir } from "winterspec/adapters/node"
+import { Request as EdgeRuntimeRequest } from "@edge-runtime/primitives"
+import { join } from "node:path"
+const serverFetch = await createFetchHandlerFromDir(
+  join(import.meta.dir, "../../routes")
+)
+export const startServer = ({ port }: { port: number }) =>
+  Bun.serve({
+    fetch: (bunReq) => {
+      const req = new EdgeRuntimeRequest(bunReq.url, {
+        headers: bunReq.headers,
+        method: bunReq.method,
+        body: bunReq.body,
+      })
+      return serverFetch(req as any)
+    },
+    port,
+  })

package/dev-server-api/tests/routes/dev_package_examples/create.test.ts ADDED Viewed

@@ -0,0 +1,19 @@
+import { it, expect } from "bun:test"
+import { getTestFixture } from "tests/fixtures/get-test-server"
+it("POST /api/dev_package_examples/create", async () => {
+  const { axios } = await getTestFixture()
+  const res = await axios
+    .post("/api/dev_package_examples/create", {
+      file_path: "examples/basic-resistor.tsx",
+      export_name: "default",
+      tscircuit_soup: [],
+      is_loading: true,
+    })
+    .then((r) => r.data)
+  expect(res.dev_package_example.file_path).toEqual(
+    "examples/basic-resistor.tsx"
+  )
+})

package/dev-server-api/tests/routes/dev_package_examples/get.test.ts ADDED Viewed

@@ -0,0 +1,25 @@
+import { it, expect } from "bun:test"
+import { getTestFixture } from "tests/fixtures/get-test-server"
+it("POST /api/dev_package_examples/create", async () => {
+  const { axios } = await getTestFixture()
+  await axios
+    .post("/api/dev_package_examples/create", {
+      file_path: "examples/basic-resistor.tsx",
+      export_name: "default",
+      tscircuit_soup: [],
+      is_loading: true,
+    })
+    .then((r) => r.data)
+  const res = await axios
+    .post("/api/dev_package_examples/get", {
+      dev_package_example_id: 1,
+    })
+    .then((r) => r.data)
+  expect(res.dev_package_example.file_path).toEqual(
+    "examples/basic-resistor.tsx"
+  )
+})

package/dev-server-api/tests/routes/dev_package_examples/list.test.ts ADDED Viewed

@@ -0,0 +1,32 @@
+import { it, expect } from "bun:test"
+import { getTestFixture } from "tests/fixtures/get-test-server"
+it("GET /api/dev_package_examples/list", async () => {
+  const { axios } = await getTestFixture()
+  // First, create a dev package example
+  await axios.post("/api/dev_package_examples/create", {
+    file_path: "examples/test-example.tsx",
+    export_name: "default",
+    tscircuit_soup: [],
+    is_loading: false,
+  })
+  // Then, list all dev package examples
+  const res = await axios
+    .post("/api/dev_package_examples/list")
+    .then((r) => r.data)
+  expect(res.dev_package_examples).toBeDefined()
+  expect(Array.isArray(res.dev_package_examples)).toBe(true)
+  expect(res.dev_package_examples.length).toBeGreaterThan(0)
+  const example = res.dev_package_examples.find(
+    (e: any) => e.file_path === "examples/test-example.tsx"
+  )
+  expect(example).toBeDefined()
+  expect(example.export_name).toBe("default")
+  expect(example.is_loading).toBe(false)
+  expect(example.dev_package_example_id).toBeDefined()
+  expect(example.last_updated_at).toBeDefined()
+})

package/dev-server-api/tests/routes/dev_package_examples/update.test.ts ADDED Viewed

@@ -0,0 +1,28 @@
+import { it, expect } from "bun:test"
+import { getTestFixture } from "tests/fixtures/get-test-server"
+it("POST /api/dev_package_examples/update", async () => {
+  const { axios } = await getTestFixture()
+  await axios
+    .post("/api/dev_package_examples/create", {
+      file_path: "examples/basic-resistor.tsx",
+      export_name: "default",
+      tscircuit_soup: [],
+      is_loading: true,
+    })
+    .then((r) => r.data)
+  const res = await axios
+    .post("/api/dev_package_examples/update", {
+      dev_package_example_id: 1,
+      completed_edit_events: [],
+      edit_events_last_applied_at: "2023-01-01T00:00:00.000Z",
+    })
+    .then((r) => r.data)
+  expect(res.dev_package_example.completed_edit_events).toEqual([])
+  expect(res.dev_package_example.edit_events_last_applied_at).toEqual(
+    "2023-01-01T00:00:00.000Z"
+  )
+})

package/dev-server-api/tests/routes/export_files/create.test.ts ADDED Viewed

@@ -0,0 +1,18 @@
+import { it, expect } from "bun:test"
+import { getTestFixture } from "tests/fixtures/get-test-server"
+it("POST /api/export_files/create", async () => {
+  const { axios } = await getTestFixture()
+  const res = await axios
+    .post("/api/export_files/create", {
+      export_request_id: 1,
+      file_name: "test.png",
+      file_content_base64:
+        "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==",
+    })
+    .then((r) => r.data)
+  expect(res.export_file.export_request_id).toEqual(1)
+  expect(res.export_file.file_name).toEqual("test.png")
+})

package/dev-server-api/tests/routes/export_files/download.test.ts ADDED Viewed

@@ -0,0 +1,29 @@
+import { it, expect } from "bun:test"
+import { getTestFixture } from "tests/fixtures/get-test-server"
+it("GET /api/export_files/download", async () => {
+  const { axios } = await getTestFixture()
+  const exampleBase64 = Buffer.from("example").toString("base64")
+  const res = await axios
+    .post("/api/export_files/create", {
+      export_request_id: 1,
+      file_name: "test.png",
+      file_content_base64: exampleBase64,
+    })
+    .then((r) => r.data)
+  const downloadRes = await axios
+    .get(
+      `/api/export_files/download?export_file_id=${res.export_file.export_file_id}`
+    )
+    .then((r) => r.data)
+  // Convert downloadRes to base64 string
+  const downloadResBase64 = Buffer.from(downloadRes, "binary").toString(
+    "base64"
+  )
+  expect(downloadResBase64).toEqual(exampleBase64)
+})