@quadrokit/client 0.1.0 → 0.2.0

package/src/generate/codegen.ts

@@ -1,317 +0,0 @@
-import { mkdir, writeFile } from 'node:fs/promises'
-import path from 'node:path'
-import type { CatalogAttribute, CatalogDataClass, CatalogJson } from '@quadrokit/shared'
-import { sessionCookieName } from '@quadrokit/shared'
-
-function map4dType(attr: CatalogAttribute): string {
-  const t = attr.type ?? 'unknown'
-  switch (t) {
-    case 'long':
-    case 'word':
-      return 'number'
-    case 'string':
-      return 'string'
-    case 'bool':
-      return 'boolean'
-    case 'number':
-      return 'number'
-    case 'date':
-      return 'string'
-    case 'duration':
-      return 'string | number'
-    case 'image':
-      return 'string | null'
-    case 'object':
-      return 'Record<string, unknown>'
-    default: {
-      if (attr.kind === 'relatedEntity') {
-        return `${t} | null`
-      }
-      if (attr.kind === 'relatedEntities' || attr.kind === 'calculated') {
-        return 'unknown'
-      }
-      return 'unknown'
-    }
-  }
-}
-
-function selectionToEntity(selectionType: string): string {
-  if (selectionType.endsWith('Selection')) {
-    return selectionType.slice(0, -'Selection'.length)
-  }
-  return selectionType
-}
-
-function navigableRelations(dc: CatalogDataClass): { attr: string; targetClass: string }[] {
-  const out: { attr: string; targetClass: string }[] = []
-  for (const a of dc.attributes ?? []) {
-    if (a.kind === 'relatedEntities') {
-      out.push({
-        attr: a.name,
-        targetClass: selectionToEntity(a.type ?? 'unknown'),
-      })
-    }
-    if (a.kind === 'calculated' && a.behavior === 'relatedEntities' && a.type) {
-      out.push({ attr: a.name, targetClass: selectionToEntity(a.type) })
-    }
-  }
-  return out
-}
-
-function relationTargets(dc: CatalogDataClass): Record<string, string> {
-  const m: Record<string, string> = {}
-  for (const a of dc.attributes ?? []) {
-    if (a.kind === 'relatedEntity' && a.type) {
-      m[a.name] = a.type
-    }
-  }
-  return m
-}
-
-function keyNames(dc: CatalogDataClass): string[] {
-  const k = dc.key?.map((x) => x.name) ?? ['ID']
-  return k.length ? k : ['ID']
-}
-
-function collectPaths(
-  dc: CatalogDataClass,
-  byName: Map<string, CatalogDataClass>,
-  maxDepth: number
-): string[] {
-  const paths = new Set<string>()
-  const visit = (current: CatalogDataClass, prefix: string, depth: number) => {
-    for (const a of current.attributes ?? []) {
-      if (a.kind === 'storage' || a.kind === 'calculated' || a.kind === 'alias') {
-        const p = prefix ? `${prefix}.${a.name}` : a.name
-        paths.add(p)
-      }
-      if (a.kind === 'relatedEntity' && a.type && depth < maxDepth) {
-        const child = byName.get(a.type)
-        const base = prefix ? `${prefix}.${a.name}` : a.name
-        paths.add(base)
-        if (child) {
-          visit(child, base, depth + 1)
-        }
-      }
-    }
-  }
-  visit(dc, '', 0)
-  return [...paths].sort()
-}
-
-function emitInterface(dc: CatalogDataClass, _byName: Map<string, CatalogDataClass>): string {
-  const lines: string[] = []
-  lines.push(`export interface ${dc.name} {`)
-  for (const a of dc.attributes ?? []) {
-    if (a.kind === 'relatedEntities') {
-      continue
-    }
-    if (a.kind === 'calculated' && a.behavior === 'relatedEntities') {
-      continue
-    }
-    const opt = a.not_null || a.identifying ? '' : '?'
-    const ts = map4dType(a)
-    lines.push(`  ${a.name}${opt}: ${ts};`)
-  }
-  lines.push('}')
-  return lines.join('\n')
-}
-
-function emitTypes(catalog: CatalogJson): string {
-  const classes = catalog.dataClasses?.filter((d) => d.exposed) ?? []
-  const byName = new Map(classes.map((c) => [c.name, c]))
-  const interfaces = classes.map((c) => emitInterface(c, byName))
-  const pathTypes = classes.map((c) => {
-    const paths = collectPaths(c, byName, 2)
-    const name = `${c.name}Path`
-    const body = paths.length ? paths.map((p) => `'${p}'`).join('\n  | ') : 'never'
-    return `export type ${name} =\n  | ${body};`
-  })
-  return `/* eslint-disable */\n/* Auto-generated by @quadrokit/client — do not edit */\n\n${interfaces.join('\n\n')}\n\n${pathTypes.join('\n\n')}\n`
-}
-
-function emitClient(catalog: CatalogJson): string {
-  const classes = catalog.dataClasses?.filter((d) => d.exposed) ?? []
-  const dbName = catalog.__NAME ?? 'default'
-  const hasAuthentify = catalog.methods?.some(
-    (m) => m.name === 'authentify' && m.applyTo === 'dataStore'
-  )
-
-  const keyNamesRecord = Object.fromEntries(classes.map((x) => [x.name, keyNames(x)] as const))
-
-  const imports = `/* eslint-disable */\n/* Auto-generated by @quadrokit/client — do not edit */\n\nimport {\n  QuadroHttp,\n  makeDataClassApi,\n  attachRelatedApis,\n  callDatastorePath,\n  type CollectionHandle,\n  type CollectionOptions,\n  type SelectedEntity,\n} from '@quadrokit/client/runtime';\n`
-
-  const typeImports = classes.map((c) => c.name).join(', ')
-  const pathImports = classes.map((c) => `${c.name}Path`).join(', ')
-  const header = `${imports}\nimport type { ${typeImports}, ${pathImports} } from './types.gen.js';\n\n`
-
-  const metaExport = `
-export const quadrokitCatalogMeta = {
-  __NAME: ${JSON.stringify(dbName)},
-  sessionCookieName: ${JSON.stringify(sessionCookieName(catalog))},
-} as const;
-`
-
-  const configInterface = `
-export interface QuadroClientConfig {
-  baseURL: string;
-  fetchImpl?: typeof fetch;
-  defaultHeaders?: Record<string, string>;
-}
-`
-
-  const mapFunctions = classes
-    .map((c) => {
-      const nav = navigableRelations(c)
-      const relMap = JSON.stringify(relationTargets(c))
-      return `  function map${c.name}Row(http: QuadroHttp, raw: unknown): ${c.name} {
-    const row = raw as ${c.name};
-    const pk = (row as { ID?: number }).ID ?? (row as { id?: number }).id;
-    attachRelatedApis(
-      raw,
-      {
-        http,
-        parentClass: '${c.name}',
-        parentId: pk as number,
-        relationMap: ${relMap},
-        keyNames: ${JSON.stringify(keyNamesRecord)},
-      },
-      ${JSON.stringify(nav)},
-    );
-    return row;
-  }`
-    })
-    .join('\n\n')
-
-  const classBranches = classes
-    .map((c) => {
-      const relMap = JSON.stringify(relationTargets(c))
-      const kn = JSON.stringify(keyNames(c))
-      const pathsType = `${c.name}Path`
-      return `    ${c.name}: (() => {
-      const cfg = {
-        http,
-        className: '${c.name}',
-        relationMap: ${relMap},
-        keyNames: ${kn},
-      } as const;
-      const api = makeDataClassApi<${c.name}>(cfg);
-      return {
-        all<S extends readonly ${pathsType}[] = readonly []>(
-          options?: CollectionOptions & { select?: S },
-        ): CollectionHandle<S['length'] extends 0 ? ${c.name} : SelectedEntity<${c.name}, S>> {
-          const inner = api.all(options as CollectionOptions);
-          return {
-            ...inner,
-            delete: inner.delete.bind(inner),
-            release: inner.release.bind(inner),
-            get length() {
-              return inner.length;
-            },
-            [Symbol.asyncIterator]() {
-              const it = inner[Symbol.asyncIterator]();
-              return {
-                async next() {
-                  const n = await it.next();
-                  if (!n.done && n.value) {
-                    map${c.name}Row(http, n.value);
-                  }
-                  return n;
-                },
-              };
-            },
-          } as CollectionHandle<S['length'] extends 0 ? ${c.name} : SelectedEntity<${c.name}, S>>;
-        },
-        async get<S extends readonly ${pathsType}[] = readonly []>(
-          id: string | number,
-          options?: { select?: S },
-        ): Promise<(S['length'] extends 0 ? ${c.name} : SelectedEntity<${c.name}, S>) | null> {
-          const entity = await api.get(id, options);
-          if (entity) {
-            map${c.name}Row(http, entity);
-          }
-          return entity as (S['length'] extends 0 ? ${c.name} : SelectedEntity<${c.name}, S>) | null;
-        },
-        delete: (id: string | number) => api.delete(id),
-        query<S extends readonly ${pathsType}[] = readonly []>(
-          filter: string,
-          options?: CollectionOptions & { params?: unknown[]; select?: S },
-        ): CollectionHandle<S['length'] extends 0 ? ${c.name} : SelectedEntity<${c.name}, S>> {
-          const inner = api.query(filter, options as CollectionOptions);
-          return {
-            ...inner,
-            delete: inner.delete.bind(inner),
-            release: inner.release.bind(inner),
-            get length() {
-              return inner.length;
-            },
-            [Symbol.asyncIterator]() {
-              const it = inner[Symbol.asyncIterator]();
-              return {
-                async next() {
-                  const n = await it.next();
-                  if (!n.done && n.value) {
-                    map${c.name}Row(http, n.value);
-                  }
-                  return n;
-                },
-              };
-            },
-          } as CollectionHandle<S['length'] extends 0 ? ${c.name} : SelectedEntity<${c.name}, S>>;
-        },
-      };
-    })(),`
-    })
-    .join('\n')
-
-  const authentifyBlock = hasAuthentify
-    ? `
-    authentify: {
-      login: (body: { email: string; password: string }) =>
-        callDatastorePath(http, ['authentify', 'login'], { body }),
-    },`
-    : ''
-
-  const body = `
-export function createClient(config: QuadroClientConfig) {
-  const http = new QuadroHttp({
-    baseURL: config.baseURL,
-    fetchImpl: config.fetchImpl,
-    defaultHeaders: config.defaultHeaders,
-  });
-
-${mapFunctions}
-
-  return {${authentifyBlock}
-${classBranches}
-    rpc: (segments: string[], init?: { method?: 'GET' | 'POST'; body?: unknown }) =>
-      callDatastorePath(http, segments, init),
-    sessionCookieName: quadrokitCatalogMeta.sessionCookieName,
-    _http: http,
-  };
-}
-
-export type QuadroClient = ReturnType<typeof createClient>;
-`
-
-  return header + metaExport + configInterface + body
-}
-
-export async function writeGenerated(outDir: string, catalog: CatalogJson): Promise<void> {
-  await mkdir(outDir, { recursive: true })
-  await writeFile(path.join(outDir, 'types.gen.ts'), emitTypes(catalog), 'utf8')
-  await writeFile(path.join(outDir, 'client.gen.ts'), emitClient(catalog), 'utf8')
-  await writeFile(
-    path.join(outDir, 'meta.json'),
-    JSON.stringify(
-      {
-        __NAME: catalog.__NAME,
-        sessionCookieName: sessionCookieName(catalog),
-        generatedAt: new Date().toISOString(),
-      },
-      null,
-      2
-    ),
-    'utf8'
-  )
-}

package/src/runtime/collection.ts

@@ -1,135 +0,0 @@
-import type { QuadroHttp } from './http.js'
-import { buildListSearchParams, type ListQueryParams } from './query.js'
-import { unwrapEntityList } from './unwrap.js'
-
-export interface CollectionContext {
-  http: QuadroHttp
-  className: string
-  relationMap: Record<string, string>
-  /** Primary key attribute names (first wins for simple path). */
-  keyNames: readonly string[]
-  path: string
-  /** Optional entity-set URL from a previous response for `release()`. */
-  entitySetUrl?: string
-}
-
-export interface CollectionOptions extends ListQueryParams {
-  page?: number
-  pageSize?: number
-  select?: readonly string[]
-}
-
-export type MapRow<R> = (raw: unknown) => R
-
-function primaryKeyFromRow(row: unknown, keyNames: readonly string[]): string | number | undefined {
-  if (!row || typeof row !== 'object') {
-    return undefined
-  }
-  const o = row as Record<string, unknown>
-  for (const k of keyNames) {
-    if (k in o && o[k] != null) {
-      return o[k] as string | number
-    }
-  }
-  return undefined
-}
-
-/**
- * Lazy paged collection: async iteration loads further pages; tracks PKs for `delete()`.
- */
-export function createCollection<R>(
-  ctx: CollectionContext,
-  initialOptions: CollectionOptions,
-  mapRow: MapRow<R>
-): CollectionHandle<R> {
-  const seenIds = new Set<string | number>()
-  let entitySetUrl = ctx.entitySetUrl
-
-  async function fetchPage(page: number): Promise<unknown[]> {
-    const qs = buildListSearchParams(ctx.className, { ...initialOptions, page }, ctx.relationMap)
-    const res = await ctx.http.request(`${ctx.path}${qs}`)
-    const text = await res.text()
-    if (!res.ok) {
-      throw new Error(`List failed ${res.status}: ${text.slice(0, 200)}`)
-    }
-    const loc = res.headers.get('Content-Location') ?? res.headers.get('Location')
-    if (loc) {
-      entitySetUrl = loc.startsWith('http')
-        ? loc
-        : `${ctx.http.baseURL}${loc.startsWith('/') ? '' : '/'}${loc}`
-    }
-    const json = text ? JSON.parse(text) : []
-    return unwrapEntityList(ctx.className, json)
-  }
-
-  async function* iteratePages(): AsyncGenerator<R, void, undefined> {
-    let page = initialOptions.page ?? 1
-    const pageSize = initialOptions.pageSize ?? 50
-    while (true) {
-      const rows = await fetchPage(page)
-      if (!rows.length) {
-        break
-      }
-      for (const raw of rows) {
-        const mapped = mapRow(raw)
-        const pk = primaryKeyFromRow(raw, ctx.keyNames)
-        if (pk !== undefined) {
-          seenIds.add(pk)
-        }
-        yield mapped
-      }
-      if (rows.length < pageSize) {
-        break
-      }
-      page += 1
-    }
-  }
-
-  const iterable: AsyncIterable<R> = {
-    [Symbol.asyncIterator]() {
-      return iteratePages()[Symbol.asyncIterator]()
-    },
-  }
-
-  const handle: CollectionHandle<R> = {
-    ...iterable,
-    async delete(): Promise<void> {
-      const ids = [...seenIds]
-      if (!ids.length) {
-        return
-      }
-      await Promise.all(
-        ids.map((id) =>
-          ctx.http.void(`${ctx.className}(${encodeURIComponent(String(id))})`, {
-            method: 'DELETE',
-          })
-        )
-      )
-      seenIds.clear()
-    },
-    async release(): Promise<void> {
-      if (entitySetUrl) {
-        try {
-          await ctx.http.void(entitySetUrl.replace(ctx.http.baseURL, '') || entitySetUrl, {
-            method: 'DELETE',
-          })
-        } catch {
-          // Some servers ignore release; swallow
-        }
-        entitySetUrl = undefined
-      }
-    },
-    get length(): number {
-      return seenIds.size
-    },
-  }
-
-  return handle
-}
-
-export type CollectionHandle<R> = AsyncIterable<R> & {
-  delete(): Promise<void>
-  release(): Promise<void>
-  /** Number of entities seen while iterating (used after partial iteration). */
-  readonly length: number
-}

package/src/runtime/data-class.ts

@@ -1,156 +0,0 @@
-import { type CollectionHandle, type CollectionOptions, createCollection } from './collection.js'
-import type { QuadroHttp } from './http.js'
-import { buildEntityParams } from './query.js'
-import { unwrapEntity, unwrapEntityList } from './unwrap.js'
-
-export interface DataClassRuntimeConfig {
-  http: QuadroHttp
-  className: string
-  /** relation attribute name → target class name for $expand */
-  relationMap: Record<string, string>
-  keyNames: readonly string[]
-}
-
-export function makeDataClassApi<R = unknown>(cfg: DataClassRuntimeConfig) {
-  const path = `/${cfg.className}`
-
-  return {
-    all<S extends readonly string[] = readonly []>(
-      options?: CollectionOptions & { select?: S }
-    ): CollectionHandle<S extends readonly never[] ? R : R> {
-      return createCollection(
-        {
-          http: cfg.http,
-          className: cfg.className,
-          relationMap: cfg.relationMap,
-          keyNames: cfg.keyNames,
-          path,
-        },
-        options ?? {},
-        (raw) => raw as R
-      )
-    },
-
-    async get<S extends readonly string[] = readonly []>(
-      id: string | number,
-      options?: { select?: S }
-    ): Promise<R | null> {
-      const qs = options?.select?.length
-        ? buildEntityParams(cfg.className, options.select, cfg.relationMap)
-        : ''
-      const key = encodeURIComponent(String(id))
-      const body = await cfg.http.json<unknown>(`${cfg.className}(${key})${qs}`)
-      return unwrapEntity<R>(cfg.className, body) as R | null
-    },
-
-    async delete(id: string | number): Promise<boolean> {
-      const key = encodeURIComponent(String(id))
-      try {
-        await cfg.http.void(`${cfg.className}(${key})`, { method: 'DELETE' })
-        return true
-      } catch {
-        return false
-      }
-    },
-
-    query<S extends readonly string[] = readonly []>(
-      filter: string,
-      options?: CollectionOptions & { params?: unknown[]; select?: S }
-    ): CollectionHandle<S extends readonly never[] ? R : R> {
-      const paramFilter = substituteQueryParams(filter, options?.params)
-      return createCollection(
-        {
-          http: cfg.http,
-          className: cfg.className,
-          relationMap: cfg.relationMap,
-          keyNames: cfg.keyNames,
-          path,
-        },
-        { ...options, filter: paramFilter },
-        (raw) => raw as R
-      )
-    },
-  }
-}
-
-function substituteQueryParams(expr: string, params?: unknown[]): string {
-  if (!params?.length) {
-    return expr
-  }
-  let out = expr
-  params.forEach((p, i) => {
-    const placeholder = `:${i + 1}`
-    const lit = formatFilterLiteral(p)
-    out = out.split(placeholder).join(lit)
-  })
-  return out
-}
-
-function formatFilterLiteral(p: unknown): string {
-  if (p === null || p === undefined) {
-    return 'null'
-  }
-  if (typeof p === 'number') {
-    return String(p)
-  }
-  if (typeof p === 'boolean') {
-    return p ? 'true' : 'false'
-  }
-  const s = String(p).replace(/'/g, "''")
-  return `'${s}'`
-}
-
-export interface EntityNavigationConfig {
-  http: QuadroHttp
-  parentClass: string
-  parentId: string | number
-  relationMap: Record<string, string>
-  keyNames: Record<string, readonly string[]>
-}
-
-/** Nested collection under an entity, e.g. `Agency(1)/todayBookings`. */
-export function makeRelatedCollectionApi(
-  cfg: EntityNavigationConfig,
-  attributeName: string,
-  targetClassName: string
-) {
-  const basePath = `/${cfg.parentClass}(${encodeURIComponent(String(cfg.parentId))})/${attributeName}`
-
-  return {
-    list<S extends readonly string[] = readonly []>(
-      options?: CollectionOptions & { select?: S }
-    ): CollectionHandle<unknown> {
-      return createCollection(
-        {
-          http: cfg.http,
-          className: targetClassName,
-          relationMap: cfg.relationMap,
-          keyNames: cfg.keyNames[targetClassName] ?? ['ID'],
-          path: basePath,
-        },
-        options ?? {},
-        (raw) => raw
-      )
-    },
-  }
-}
-
-export function attachRelatedApis(
-  row: unknown,
-  cfg: EntityNavigationConfig,
-  relations: readonly { attr: string; targetClass: string }[]
-): void {
-  if (!row || typeof row !== 'object') {
-    return
-  }
-  const obj = row as Record<string, unknown>
-  for (const { attr, targetClass } of relations) {
-    Object.defineProperty(obj, attr, {
-      enumerable: false,
-      configurable: true,
-      value: makeRelatedCollectionApi(cfg, attr, targetClass),
-    })
-  }
-}
-
-export { unwrapEntityList }

package/src/runtime/datastore.ts

@@ -1,25 +0,0 @@
-import type { QuadroHttp } from './http.js'
-
-/** Call nested datastore paths like `authentify/login` (POST by default). */
-export async function callDatastorePath(
-  http: QuadroHttp,
-  segments: readonly string[],
-  init?: { method?: 'GET' | 'POST'; body?: unknown }
-): Promise<unknown> {
-  const path = `/${segments.join('/')}`
-  const method = init?.method ?? 'POST'
-  if (method === 'GET') {
-    return http.json(path, { method: 'GET' })
-  }
-  return http.json(path, {
-    method: 'POST',
-    body: init?.body !== undefined ? JSON.stringify(init.body) : undefined,
-  })
-}
-
-export function createDatastoreNamespace(
-  _http: QuadroHttp,
-  tree: Record<string, unknown>
-): Record<string, unknown> {
-  return tree
-}

package/src/runtime/errors.ts

@@ -1,11 +0,0 @@
-export class QuadroHttpError extends Error {
-  readonly status: number
-  readonly body: string
-
-  constructor(status: number, body: string) {
-    super(`Quadro HTTP ${status}: ${body.slice(0, 200)}`)
-    this.name = 'QuadroHttpError'
-    this.status = status
-    this.body = body
-  }
-}

package/src/runtime/http.ts

@@ -1,64 +0,0 @@
-import { QuadroHttpError } from './errors.js'
-
-export interface QuadroFetchOptions {
-  baseURL: string
-  fetchImpl?: typeof fetch
-  /** Extra headers on every request (e.g. Authorization for generate). */
-  defaultHeaders?: Record<string, string>
-}
-
-export function normalizeBaseURL(baseURL: string): string {
-  return baseURL.replace(/\/$/, '')
-}
-
-export class QuadroHttp {
-  constructor(private readonly opts: QuadroFetchOptions) {}
-
-  get baseURL(): string {
-    return normalizeBaseURL(this.opts.baseURL)
-  }
-
-  async request(path: string, init: RequestInit = {}): Promise<Response> {
-    const url = path.startsWith('http')
-      ? path
-      : `${this.baseURL}${path.startsWith('/') ? '' : '/'}${path}`
-    const headers = new Headers(init.headers)
-    if (!headers.has('Accept')) {
-      headers.set('Accept', 'application/json')
-    }
-    if (init.body !== undefined && !headers.has('Content-Type')) {
-      headers.set('Content-Type', 'application/json')
-    }
-    for (const [k, v] of Object.entries(this.opts.defaultHeaders ?? {})) {
-      if (!headers.has(k)) {
-        headers.set(k, v)
-      }
-    }
-    const fetchFn = this.opts.fetchImpl ?? fetch
-    return fetchFn(url, {
-      credentials: 'include',
-      ...init,
-      headers,
-    })
-  }
-
-  async json<T>(path: string, init: RequestInit = {}): Promise<T> {
-    const res = await this.request(path, init)
-    const text = await res.text()
-    if (!res.ok) {
-      throw new QuadroHttpError(res.status, text)
-    }
-    if (!text) {
-      return undefined as T
-    }
-    return JSON.parse(text) as T
-  }
-
-  async void(path: string, init: RequestInit = {}): Promise<void> {
-    const res = await this.request(path, init)
-    if (!res.ok) {
-      const text = await res.text()
-      throw new QuadroHttpError(res.status, text)
-    }
-  }
-}