@redonvn/redai-backend-api-sdk 0.1.17 → 0.1.20

package/src/index.ts

@@ -1,79 +0,0 @@
-import { DynamicTableAuth } from './core/auth';
-import { HttpClient } from './core/http-client';
-import { DynamicTableSdkConfig, DynamicTableTokenProvider } from './core/types';
-import { ApiDocsService, ApiTokensService, AttachmentsSecureService, AttachmentsService, BaseMembersService, BasesService, CachesService, CalendarDataService, CalendarsService, ColumnsService, CommandPaletteService, DataTableService, DynamicTableAuthService, FiltersService, FormsService, GalleriesService, GridsService, HooksService, InternalService, KanbanDataService, KanbansService, MapsService, RowColorService, SortsService, SourcesService, TablesService, UserUiPreferencesService, UtilsService, ViewColumnsService, ViewsService, WorkspaceInviteLinkSettingsService, WorkspaceInviteLinksService, WorkspaceInvitesService, WorkspaceJoinRequestsService, WorkspaceMembersService, WorkspacesService } from './generated/services';
-
-export type { ApiResponseDto, DynamicTableSdkConfig, DynamicTableTokenProvider } from './core/types';
-export * from './generated';
-
-export const createFrontendAxiosTokenProvider = (options?: {
-  authStorageKey?: string;
-  dtApiToken?: string | null;
-  getDtApiToken?: () => string | null | undefined;
-}) => {
-  const authStorageKey = options?.authStorageKey ?? 'auth_data';
-  return {
-    getBearerToken: () => {
-      const storage = (globalThis as { localStorage?: { getItem: (key: string) => string | null } }).localStorage;
-      if (!storage) return null;
-      try {
-        const raw = storage.getItem(authStorageKey);
-        if (!raw) return null;
-        const parsed = JSON.parse(raw) as { accessToken?: string; expiresAt?: number };
-        if (!parsed?.accessToken) return null;
-        if (typeof parsed.expiresAt === 'number' && parsed.expiresAt <= Date.now()) return null;
-        return parsed.accessToken;
-      } catch {
-        return null;
-      }
-    },
-    getDtApiToken: () => options?.getDtApiToken?.() ?? options?.dtApiToken ?? null,
-  } as const;
-};
-
-export const createDynamicTableSdk = (config: DynamicTableSdkConfig) => {
-  const auth = new DynamicTableAuth({ bearerToken: config.bearerToken ?? null, dtApiToken: config.dtApiToken ?? null }, config.tokenProvider);
-  const client = new HttpClient(config, auth);
-  const viewColumns = new ViewColumnsService(client);
-  return {
-    auth,
-    apiDocs: new ApiDocsService(client),
-    apiTokens: new ApiTokensService(client),
-    attachmentsSecure: new AttachmentsSecureService(client),
-    attachments: new AttachmentsService(client),
-    baseMembers: new BaseMembersService(client),
-    bases: new BasesService(client),
-    caches: new CachesService(client),
-    calendarData: new CalendarDataService(client),
-    calendars: new CalendarsService(client),
-    columns: new ColumnsService(client),
-    commandPalette: new CommandPaletteService(client),
-    dataTable: new DataTableService(client),
-    authService: new DynamicTableAuthService(client),
-    filters: new FiltersService(client),
-    forms: new FormsService(client),
-    galleries: new GalleriesService(client),
-    grids: new GridsService(client),
-    hooks: new HooksService(client),
-    internal: new InternalService(client),
-    kanbanData: new KanbanDataService(client),
-    kanbans: new KanbansService(client),
-    maps: new MapsService(client),
-    rowColor: new RowColorService(client),
-    sorts: new SortsService(client),
-    sources: new SourcesService(client),
-    tables: new TablesService(client),
-    userUiPreferences: new UserUiPreferencesService(client),
-    utils: new UtilsService(client),
-    views: new ViewsService(client),
-    workspaceInviteLinkSettings: new WorkspaceInviteLinkSettingsService(client),
-    workspaceInviteLinks: new WorkspaceInviteLinksService(client),
-    workspaceInvites: new WorkspaceInvitesService(client),
-    workspaceJoinRequests: new WorkspaceJoinRequestsService(client),
-    workspaceMembers: new WorkspaceMembersService(client),
-    workspaces: new WorkspacesService(client),
-    formColumns: viewColumns,
-    gridColumns: viewColumns,
-    viewColumns,
-  };
-};

package/tools/.reports/dynamic-table-sdk-report.json

@@ -1,9 +0,0 @@
-{
-  "moduleName": "dynamic-table",
-  "mode": "ts",
-  "totalOperations": 162,
-  "resolvedByOpenapi": 0,
-  "resolvedByTs": 162,
-  "unresolved": [],
-  "conflicts": []
-}

package/tools/generate-dynamic-table-sdk.ts

@@ -1,31 +0,0 @@
-import { spawnSync } from 'child_process';
-import * as path from 'path';
-
-const toolRoot = 'F:/Redon/sdk/generic-sdk-api';
-const cliPath = path.join(toolRoot, 'src', 'cli.ts');
-
-const args = process.argv.slice(2);
-const defaults = [
-  '--module=dynamic-table',
-  `--backendRoot=${process.env.BACKEND_ROOT ?? 'F:/Redon/DuAn/project01/true'}`,
-  `--controllersDir=${process.env.CONTROLLERS_GLOB ?? 'src/modules/dynamic-table/controllers'}`,
-  `--pathPrefix=${process.env.PATH_PREFIX ?? '/v1/dynamic-table'}`,
-  `--outDir=${process.cwd()}`,
-  `--mode=${process.env.GEN_MODE ?? 'ts'}`,
-  `--outputReport=${process.env.OUTPUT_REPORT ?? 'true'}`,
-  '--syncRootIndex=true',
-];
-
-const openApiPath = process.env.OPENAPI_PATH ?? 'F:/Redon/DuAn/project01/true/src/modules/dynamic-table/tests/curl/docs-json.json';
-if ((process.env.GEN_MODE ?? 'ts') !== 'ts') {
-  defaults.push(`--openapi=${openApiPath}`);
-}
-
-const result = spawnSync('npx', ['tsx', cliPath, 'generate', ...defaults, ...args], {
-  stdio: 'inherit',
-  shell: process.platform === 'win32',
-});
-
-if (result.status !== 0) {
-  process.exit(result.status ?? 1);
-}

package/tools/generate-sdk.ts

@@ -1,13 +0,0 @@
-import { spawnSync } from 'child_process';
-import * as path from 'path';
-
-const toolRoot = 'F:/Redon/sdk/generic-sdk-api';
-const cliPath = path.join(toolRoot, 'src', 'cli.ts');
-
-const args = process.argv.slice(2);
-const result = spawnSync('npx', ['tsx', cliPath, 'generate', ...args], {
-  stdio: 'inherit',
-  shell: process.platform === 'win32',
-});
-
-if (result.status !== 0) process.exit(result.status ?? 1);

package/tools/generator/openapi-resolver.ts

@@ -1,77 +0,0 @@
-import * as crypto from 'crypto';
-import { getRefTypeName, normalizeNullable, primitiveForType, sanitizePropertyName, sanitizeTypeName, SchemaObject, OperationObject } from './shared';
-
-export const INLINE_TYPES: string[] = [];
-export const INLINE_TYPE_CACHE = new Map<string, string>();
-
-const toLiteral = (v: string | number | boolean | null): string => {
-  if (v === null) return 'null';
-  if (typeof v === 'string') return `'${v.replace(/'/g, "\\'")}'`;
-  return String(v);
-};
-
-export const schemaToTs = (schema: SchemaObject | undefined, ctxName: string): string => {
-  if (!schema) return 'unknown';
-  if (schema.$ref) return getRefTypeName(schema.$ref);
-  if (schema.oneOf?.length) return normalizeNullable(schema.oneOf.map((s, i) => schemaToTs(s, `${ctxName}OneOf${i}`)).join(' | '), schema.nullable);
-  if (schema.anyOf?.length) return normalizeNullable(schema.anyOf.map((s, i) => schemaToTs(s, `${ctxName}AnyOf${i}`)).join(' | '), schema.nullable);
-  if (schema.allOf?.length) return normalizeNullable(schema.allOf.map((s, i) => schemaToTs(s, `${ctxName}AllOf${i}`)).join(' & '), schema.nullable);
-  if (schema.enum?.length) return normalizeNullable(schema.enum.map(toLiteral).join(' | '), schema.nullable);
-  if (schema.type === 'array') return normalizeNullable(`(${schemaToTs(schema.items, `${ctxName}Item`)})[]`, schema.nullable);
-
-  if (schema.type === 'object' || schema.properties || schema.additionalProperties) {
-    const req = new Set(schema.required ?? []);
-    const props = Object.entries(schema.properties ?? {}).map(([k, v]) => `  ${sanitizePropertyName(k)}${req.has(k) ? '' : '?'}: ${schemaToTs(v, `${ctxName}${sanitizeTypeName(k)}`)};`);
-    const add = schema.additionalProperties === true
-      ? '\n  [key: string]: unknown;'
-      : schema.additionalProperties && typeof schema.additionalProperties === 'object'
-        ? `\n  [key: string]: ${schemaToTs(schema.additionalProperties, `${ctxName}Additional`)};`
-        : '';
-    return normalizeNullable(`\n{\n${props.join('\n')}${add}\n}`, schema.nullable);
-  }
-
-  return normalizeNullable(primitiveForType(schema.type, schema.format), schema.nullable);
-};
-
-export const schemaToNamedType = (schema: SchemaObject | undefined, preferredName: string): string => {
-  if (!schema) return 'unknown';
-  if (schema.$ref) return getRefTypeName(schema.$ref);
-  const hash = crypto.createHash('sha1').update(JSON.stringify(schema)).digest('hex').slice(0, 10);
-  const cached = INLINE_TYPE_CACHE.get(hash);
-  if (cached) return cached;
-
-  const typeName = sanitizeTypeName(preferredName);
-  const finalName = INLINE_TYPES.some((l) => l.includes(`export type ${typeName} =`)) ? `${typeName}${hash}` : typeName;
-  INLINE_TYPES.push(`export type ${finalName} = ${schemaToTs(schema, finalName)};`);
-  INLINE_TYPE_CACHE.set(hash, finalName);
-  return finalName;
-};
-
-export const pickMediaSchema = (content: Record<string, { schema?: SchemaObject }> | undefined): SchemaObject | undefined => {
-  if (!content) return undefined;
-  return content['application/json']?.schema || content['application/*+json']?.schema || Object.values(content)[0]?.schema;
-};
-
-export const getOpenApiResponseType = (operation: OperationObject, operationName: string): string => {
-  const responses = operation.responses ?? {};
-  const ok = ['200', '201', '202', '203', '204'].find((s) => responses[s]);
-  if (!ok) return 'unknown';
-  if (ok === '204') return 'void';
-  const schema = pickMediaSchema(responses[ok]?.content);
-  if (!schema) return 'unknown';
-  return schemaToNamedType(schema, `${operationName}Response`);
-};
-
-export const collectRefsFromSchema = (schema: SchemaObject | undefined, refs: Set<string>): void => {
-  if (!schema) return;
-  if (schema.$ref) {
-    refs.add(getRefTypeName(schema.$ref));
-    return;
-  }
-  for (const s of schema.oneOf ?? []) collectRefsFromSchema(s, refs);
-  for (const s of schema.anyOf ?? []) collectRefsFromSchema(s, refs);
-  for (const s of schema.allOf ?? []) collectRefsFromSchema(s, refs);
-  if (schema.items) collectRefsFromSchema(schema.items, refs);
-  for (const p of Object.values(schema.properties ?? {})) collectRefsFromSchema(p, refs);
-  if (schema.additionalProperties && typeof schema.additionalProperties === 'object') collectRefsFromSchema(schema.additionalProperties, refs);
-};

package/tools/generator/shared.ts

@@ -1,162 +0,0 @@
-export type HttpMethod = 'get' | 'post' | 'put' | 'patch' | 'delete' | 'options' | 'head';
-export type GenMode = 'openapi' | 'ts' | 'hybrid';
-export type ResolveSource = 'openapi' | 'ts' | 'unknown';
-
-export type SchemaObject = {
-  $ref?: string;
-  type?: string;
-  format?: string;
-  enum?: Array<string | number | boolean | null>;
-  nullable?: boolean;
-  items?: SchemaObject;
-  properties?: Record<string, SchemaObject>;
-  required?: string[];
-  oneOf?: SchemaObject[];
-  anyOf?: SchemaObject[];
-  allOf?: SchemaObject[];
-  additionalProperties?: boolean | SchemaObject;
-};
-
-export type ParameterObject = {
-  name: string;
-  in: 'path' | 'query' | 'header' | 'cookie';
-  required?: boolean;
-  schema?: SchemaObject;
-};
-
-export type RequestBodyObject = {
-  required?: boolean;
-  content?: Record<string, { schema?: SchemaObject }>;
-};
-
-export type OperationObject = {
-  operationId?: string;
-  parameters?: ParameterObject[];
-  requestBody?: RequestBodyObject;
-  responses?: Record<string, { content?: Record<string, { schema?: SchemaObject }> }>;
-};
-
-export type OpenApiDoc = {
-  openapi: string;
-  paths: Record<string, Record<string, OperationObject> & { parameters?: ParameterObject[] }>;
-  components?: { schemas?: Record<string, SchemaObject> };
-};
-
-export type OperationMeta = {
-  path: string;
-  method: HttpMethod;
-  operationId: string;
-  domain: string;
-  methodName: string;
-  responseType: string;
-  responseSource: ResolveSource;
-  paramsTypeName: string;
-  pathParams: OperationParamMeta[];
-  queryParams: OperationParamMeta[];
-  headerParams: OperationParamMeta[];
-  queryTypeName?: string;
-  bodySchema?: SchemaObject;
-  bodyTypeName?: string;
-  bodyRequired: boolean;
-};
-
-export type TsRouteInfo = { method: HttpMethod; path: string; responseType: string };
-export type OperationParamMeta = ParameterObject & { typeName?: string };
-export type TsResolvedOperation = {
-  method: HttpMethod;
-  path: string;
-  actionName: string;
-  responseType: string;
-  pathParams: Array<{ name: string; typeName: string }>;
-  queryTypeName?: string;
-  bodyTypeName?: string;
-  bodyRequired: boolean;
-  headerParams: Array<{ name: string; typeName: string; required: boolean }>;
-};
-
-export type GeneratorReport = {
-  moduleName: string;
-  mode: GenMode;
-  totalOperations: number;
-  resolvedByOpenapi: number;
-  resolvedByTs: number;
-  unresolved: Array<{ method: string; path: string; operationId: string }>;
-  conflicts: Array<{ method: string; path: string; operationId: string; openapiType: string; tsType: string }>;
-};
-
-export const METHODS: HttpMethod[] = ['get', 'post', 'put', 'patch', 'delete', 'options', 'head'];
-
-export const sanitizeTypeName = (s: string): string =>
-  (s.replace(/[^a-zA-Z0-9_]/g, '_').split(/[_\-\s]+/).filter(Boolean).map((p) => p[0].toUpperCase() + p.slice(1)).join('')) || 'UnnamedType';
-
-export const sanitizePropertyName = (n: string): string => (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(n) ? n : `'${n.replace(/'/g, "\\'")}'`);
-
-export const normalizeApiPath = (p: string, prependV1ForModule?: string): string => {
-  const v = (p.startsWith('/') ? p : `/${p}`).replace(/\/+/g, '/').replace(/:([a-zA-Z0-9_]+)/g, '{$1}');
-  const withPrefix = prependV1ForModule && v.startsWith(`/${prependV1ForModule}`) ? `/v1${v}` : v;
-  return withPrefix.length > 1 && withPrefix.endsWith('/') ? withPrefix.slice(0, -1) : withPrefix;
-};
-
-export const joinPaths = (a: string, b: string, modulePrefix?: string): string => normalizeApiPath(`${a.trim()}/${b.trim()}`, modulePrefix);
-
-export const parseBool = (v: string | undefined, d: boolean): boolean => (!v ? d : ['1', 'true', 'yes', 'on'].includes(v.toLowerCase()));
-
-export const getRefTypeName = (ref: string): string => sanitizeTypeName(ref.split('/').pop() || 'UnknownRef');
-
-export const normalizeNullable = (base: string, nullable?: boolean): string => (nullable ? `${base} | null` : base);
-
-export const primitiveForType = (type?: string, format?: string): string => {
-  if (!type) return 'unknown';
-  if (type === 'integer' || type === 'number') return 'number';
-  if (type === 'boolean') return 'boolean';
-  if (type === 'string') return format === 'binary' ? 'Blob' : 'string';
-  if (type === 'null') return 'null';
-  if (type === 'object') return 'Record<string, unknown>';
-  if (type === 'array') return 'unknown[]';
-  return 'unknown';
-};
-
-export const dedupeParameters = (a: ParameterObject[] | undefined, b: ParameterObject[] | undefined): ParameterObject[] => {
-  const map = new Map<string, ParameterObject>();
-  for (const p of [...(a ?? []), ...(b ?? [])]) map.set(`${p.in}:${p.name}`, p);
-  return [...map.values()];
-};
-
-export const fallbackMethodName = (method: HttpMethod, apiPath: string): string => {
-  const parts = apiPath.split('/').filter(Boolean).map((s) => (s.startsWith('{') ? `By${sanitizeTypeName(s.replace(/[{}]/g, ''))}` : sanitizeTypeName(s)));
-  return `${method}${parts.join('')}`.replace(/^[A-Z]/, (c) => c.toLowerCase());
-};
-
-export const normalizeMethodName = (operationId: string, method: HttpMethod, apiPath: string): string => {
-  if (!operationId.trim()) return fallbackMethodName(method, apiPath);
-  const stripped = operationId.replace(/^[^_]+_/, '');
-  const camel = stripped.replace(/[^a-zA-Z0-9]+(.)/g, (_, c: string) => c.toUpperCase()).replace(/^[A-Z]/, (c) => c.toLowerCase());
-  return camel || fallbackMethodName(method, apiPath);
-};
-
-export const resolveDomain = (apiPath: string, pathPrefix: string): string => {
-  const cleanPrefix = pathPrefix.replace(/\/$/, '');
-  const metaPrefix = `${cleanPrefix}/db/meta/`;
-  const dataPrefix = `${cleanPrefix}/db/data/`;
-  if (apiPath.startsWith(metaPrefix)) return (apiPath.slice(metaPrefix.length).split('/').filter(Boolean)[0] || 'meta').toLowerCase();
-  if (apiPath.startsWith(dataPrefix)) return 'data-table';
-  if (apiPath.startsWith(`${cleanPrefix}/`)) return (apiPath.slice(`${cleanPrefix}/`.length).split('/').filter(Boolean)[0] || 'common').toLowerCase();
-  return 'common';
-};
-
-export const BUILTIN_TYPE_NAMES = new Set(['string', 'number', 'boolean', 'unknown', 'void', 'null', 'undefined', 'never', 'any', 'Record', 'Array', 'Blob', 'Date', 'Object', 'Promise', 'ReadonlyArray', 'Partial', 'Pick', 'Omit', 'Required']);
-
-export const extractTypeIdentifiers = (typeExpr: string): string[] => {
-  const m = typeExpr.match(/[A-Za-z_][A-Za-z0-9_]*/g) ?? [];
-  return [...new Set(m.filter((n) => !BUILTIN_TYPE_NAMES.has(n) && /^[A-Z]/.test(n)))];
-};
-
-export const extractGenericTypeNames = (typeExpr: string): string[] => {
-  const out = new Set<string>();
-  const regex = /([A-Za-z_][A-Za-z0-9_]*)\s*</g;
-  let match: RegExpExecArray | null;
-  while ((match = regex.exec(typeExpr)) !== null) {
-    if (!BUILTIN_TYPE_NAMES.has(match[1]) && /^[A-Z]/.test(match[1])) out.add(match[1]);
-  }
-  return [...out];
-};