@cartanova/qgrid-cli 1.9.0 → 2.0.1

package/bundle/web-dist/server/assets/{services.generated-Q2ZIxMdn.js → services.generated-C39hdSv0.js}

@@ -1,4 +1,4 @@
-import { $ as timeUntilStale, A as hasNextPage, B as hashKey, D as require_react, E as require_jsx_runtime, G as noop, H as isValidTimeout, I as notifyManager, J as resolveEnabled, L as pendingThenable, M as infiniteQueryBehavior, P as fetchState, R as environmentManager, S as require_lib, T as useQueryClient, X as shallowEqualObjects, Y as resolveStaleTime, Z as shouldThrowError, a as dedupeAndFlatten, et as timeoutManager, j as hasPreviousPage, k as getDefaultState, nt as Subscribable, o as fetch, ot as __toESM, q as replaceData, s as useRefreshable, tt as focusManager } from "./sd.generated-CkiEsOwK.js";
+import { B as shouldThrowError, C as fetchState, D as environmentManager, E as pendingThenable, G as Subscribable, H as timeUntilStale, I as replaceData, L as resolveEnabled, P as noop, R as resolveStaleTime, T as notifyManager, U as timeoutManager, W as focusManager, Y as __toESM, a as fetch, b as hasPreviousPage, d as require_lib, g as require_react, h as require_jsx_runtime, i as dedupeAndFlatten, j as isValidTimeout, k as hashKey, m as useQueryClient, o as useRefreshable, s as useSSEStream, v as getDefaultState, x as infiniteQueryBehavior, y as hasNextPage, z as shallowEqualObjects } from "./sd.generated-BeUHLWKH.js";
 //#region ../../node_modules/.pnpm/@tanstack+query-core@5.95.2/node_modules/@tanstack/query-core/build/modern/queryObserver.js
 var QueryObserver = class extends Subscribable {
 	constructor(client, options) {
@@ -743,6 +743,96 @@ var TokenService;
 	_TokenService.del = del;
 	_TokenService.useDelMutation = () => useMutation({ mutationFn: (params) => del(params.ids) });
 })(TokenService || (TokenService = {}));
+var RequestLogStepService;
+(function(_RequestLogStepService) {
+	async function getRequestLogStep(subset, id) {
+		return fetch({
+			method: "GET",
+			url: `/api/requestLogStep/findById?${import_lib.default.stringify({
+				subset,
+				id
+			})}`
+		});
+	}
+	_RequestLogStepService.getRequestLogStep = getRequestLogStep;
+	const getRequestLogStepQueryOptions = _RequestLogStepService.getRequestLogStepQueryOptions = (subset, id) => queryOptions({
+		queryKey: [
+			"RequestLogStep",
+			"getRequestLogStep",
+			subset,
+			id
+		],
+		queryFn: () => getRequestLogStep(subset, id)
+	});
+	_RequestLogStepService.useRequestLogStep = (subset, id, options) => useRefreshable(useQuery({
+		...getRequestLogStepQueryOptions(subset, id),
+		...options
+	}));
+	async function getRequestLogSteps(subset, rawParams) {
+		return fetch({
+			method: "GET",
+			url: `/api/requestLogStep/findMany?${import_lib.default.stringify({
+				subset,
+				rawParams
+			})}`
+		});
+	}
+	_RequestLogStepService.getRequestLogSteps = getRequestLogSteps;
+	const getRequestLogStepsQueryOptions = _RequestLogStepService.getRequestLogStepsQueryOptions = (subset, rawParams) => queryOptions({
+		queryKey: [
+			"RequestLogStep",
+			"getRequestLogSteps",
+			subset,
+			rawParams
+		],
+		queryFn: () => getRequestLogSteps(subset, rawParams)
+	});
+	_RequestLogStepService.useRequestLogSteps = (subset, rawParams, options) => useRefreshable(useQuery({
+		...getRequestLogStepsQueryOptions(subset, rawParams),
+		...options
+	}));
+	const getRequestLogStepsInfiniteQueryOptions = _RequestLogStepService.getRequestLogStepsInfiniteQueryOptions = (subset, rawParams) => infiniteQueryOptions({
+		queryKey: [
+			"RequestLogStep",
+			"getRequestLogSteps",
+			"infinite",
+			subset,
+			rawParams
+		],
+		queryFn: ({ pageParam }) => getRequestLogSteps(subset, {
+			...rawParams,
+			page: pageParam
+		}),
+		initialPageParam: 1,
+		getNextPageParam: (lastPage, allPages) => {
+			const total = lastPage?.total ?? 0;
+			return allPages.reduce((sum, p) => sum + (p?.rows?.length ?? 0), 0) < total ? allPages.length + 1 : void 0;
+		},
+		select: dedupeAndFlatten
+	});
+	_RequestLogStepService.useRequestLogStepsInfinite = (subset, rawParams, options) => useRefreshable(useInfiniteQuery({
+		...getRequestLogStepsInfiniteQueryOptions(subset, rawParams),
+		...options
+	}));
+	async function save(spa) {
+		return fetch({
+			method: "POST",
+			url: `/api/requestLogStep/save`,
+			data: { spa }
+		});
+	}
+	_RequestLogStepService.save = save;
+	_RequestLogStepService.useSaveMutation = () => useMutation({ mutationFn: (params) => save(params.spa) });
+	async function del(ids) {
+		return fetch({
+			method: "POST",
+			url: `/api/requestLogStep/del`,
+			data: { ids }
+		});
+	}
+	_RequestLogStepService.del = del;
+	_RequestLogStepService.useDelMutation = () => useMutation({ mutationFn: (params) => del(params.ids) });
+})(RequestLogStepService || (RequestLogStepService = {}));
 var RequestLogService;
 (function(_RequestLogService) {
 	async function getRequestLog(subset, id) {
@@ -835,23 +925,55 @@ var RequestLogService;
 })(RequestLogService || (RequestLogService = {}));
 var QgridService;
 (function(_QgridService) {
-	async function query(prompt, system, timeout, model, projectName, jsonSchema, effort) {
+	async function query(args) {
 		return fetch({
 			method: "POST",
 			url: `/api/qgrid/query`,
-			data: {
-				prompt,
-				system,
-				timeout,
-				model,
-				projectName,
-				jsonSchema,
-				effort
-			}
+			data: { args }
 		});
 	}
 	_QgridService.query = query;
-	_QgridService.useQueryMutation = () => useMutation({ mutationFn: (params) => query(params.prompt, params.system, params.timeout, params.model, params.projectName, params.jsonSchema, params.effort) });
+	_QgridService.useQueryMutation = () => useMutation({ mutationFn: (params) => query(params.args) });
+	async function prepareStream(args) {
+		return fetch({
+			method: "POST",
+			url: `/api/qgrid/prepareStream`,
+			data: { args }
+		});
+	}
+	_QgridService.prepareStream = prepareStream;
+	_QgridService.usePrepareStreamMutation = () => useMutation({ mutationFn: (params) => prepareStream(params.args) });
+	function useQueryStream(params, handlers, options) {
+		return useSSEStream(`/api/qgrid/queryStream`, params, handlers, options);
+	}
+	_QgridService.useQueryStream = useQueryStream;
+	async function createRun(input) {
+		return fetch({
+			method: "POST",
+			url: `/api/qgrid/createRun`,
+			data: { input }
+		});
+	}
+	_QgridService.createRun = createRun;
+	_QgridService.useCreateRunMutation = () => useMutation({ mutationFn: (params) => createRun(params.input) });
+	async function appendStep(input) {
+		return fetch({
+			method: "POST",
+			url: `/api/qgrid/appendStep`,
+			data: { input }
+		});
+	}
+	_QgridService.appendStep = appendStep;
+	_QgridService.useAppendStepMutation = () => useMutation({ mutationFn: (params) => appendStep(params.input) });
+	async function finishRun(input) {
+		return fetch({
+			method: "POST",
+			url: `/api/qgrid/finishRun`,
+			data: { input }
+		});
+	}
+	_QgridService.finishRun = finishRun;
+	_QgridService.useFinishRunMutation = () => useMutation({ mutationFn: (params) => finishRun(params.input) });
 	async function stats() {
 		return fetch({
 			method: "GET",
@@ -901,42 +1023,40 @@ var QgridService;
 		...projectNamesQueryOptions(),
 		...options
 	}));
-	async function addToken(token, name, refreshToken) {
+	async function addToken(provider, credentials, name) {
 		return fetch({
 			method: "POST",
 			url: `/api/qgrid/addToken`,
 			data: {
-				token,
-				name,
-				refreshToken
+				provider,
+				credentials,
+				name
 			}
 		});
 	}
 	_QgridService.addToken = addToken;
-	_QgridService.useAddTokenMutation = () => useMutation({ mutationFn: (params) => addToken(params.token, params.name, params.refreshToken) });
-	async function updateToken(token, name, newToken, refreshToken) {
+	_QgridService.useAddTokenMutation = () => useMutation({ mutationFn: (params) => addToken(params.provider, params.credentials, params.name) });
+	async function updateToken(id, name) {
 		return fetch({
 			method: "POST",
 			url: `/api/qgrid/updateToken`,
 			data: {
-				token,
-				name,
-				newToken,
-				refreshToken
+				id,
+				name
 			}
 		});
 	}
 	_QgridService.updateToken = updateToken;
-	_QgridService.useUpdateTokenMutation = () => useMutation({ mutationFn: (params) => updateToken(params.token, params.name, params.newToken, params.refreshToken) });
-	async function removeToken(token) {
+	_QgridService.useUpdateTokenMutation = () => useMutation({ mutationFn: (params) => updateToken(params.id, params.name) });
+	async function removeToken(id) {
 		return fetch({
 			method: "POST",
 			url: `/api/qgrid/removeToken`,
-			data: { token }
+			data: { id }
 		});
 	}
 	_QgridService.removeToken = removeToken;
-	_QgridService.useRemoveTokenMutation = () => useMutation({ mutationFn: (params) => removeToken(params.token) });
+	_QgridService.useRemoveTokenMutation = () => useMutation({ mutationFn: (params) => removeToken(params.id) });
 	async function toggleToken(id) {
 		return fetch({
 			method: "POST",
@@ -955,23 +1075,32 @@ var QgridService;
 	}
 	_QgridService.oauthStart = oauthStart;
 	_QgridService.useOauthStartMutation = () => useMutation({ mutationFn: (params) => oauthStart(params.name) });
-	async function usage(tokenName) {
+	async function oauthStartOpenAI(name) {
+		return fetch({
+			method: "POST",
+			url: `/api/qgrid/oauthStartOpenAI`,
+			data: { name }
+		});
+	}
+	_QgridService.oauthStartOpenAI = oauthStartOpenAI;
+	_QgridService.useOauthStartOpenAIMutation = () => useMutation({ mutationFn: (params) => oauthStartOpenAI(params.name) });
+	async function usage(tokenId) {
 		return fetch({
 			method: "GET",
-			url: `/api/qgrid/usage?${import_lib.default.stringify({ tokenName })}`
+			url: `/api/qgrid/usage?${import_lib.default.stringify({ tokenId })}`
 		});
 	}
 	_QgridService.usage = usage;
-	const usageQueryOptions = _QgridService.usageQueryOptions = (tokenName) => queryOptions({
+	const usageQueryOptions = _QgridService.usageQueryOptions = (tokenId) => queryOptions({
 		queryKey: [
 			"Qgrid",
 			"usage",
-			tokenName
+			tokenId
 		],
-		queryFn: () => usage(tokenName)
+		queryFn: () => usage(tokenId)
 	});
-	_QgridService.useUsage = (tokenName, options) => useRefreshable(useQuery({
-		...usageQueryOptions(tokenName),
+	_QgridService.useUsage = (tokenId, options) => useRefreshable(useQuery({
+		...usageQueryOptions(tokenId),
 		...options
 	}));
 	async function health() {
@@ -991,6 +1120,7 @@ var QgridService;
 	}));
 })(QgridService || (QgridService = {}));
 RequestLogService.useRequestLogs, RequestLogService.useRequestLogsInfinite;
+RequestLogStepService.useRequestLogSteps, RequestLogStepService.useRequestLogStepsInfinite;
 TokenService.useTokens, TokenService.useTokensInfinite;
 //#endregion
-export { RequestLogService as n, TokenService as r, QgridService as t };
+export { TokenService as i, RequestLogService as n, RequestLogStepService as r, QgridService as t };

package/bundle/web-dist/server/assets/{shim-BYpcQGN1.js → shim-B9ZrFt3Z.js}

@@ -1,4 +1,4 @@
-import { D as require_react, rt as __commonJSMin } from "./sd.generated-CkiEsOwK.js";
+import { K as __commonJSMin, g as require_react } from "./sd.generated-BeUHLWKH.js";
 //#region ../../node_modules/.pnpm/use-sync-external-store@1.6.0_react@19.2.4/node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.production.js
 /**
 * @license React