Add smart member list with manual+login merge and duplicate detection
This commit is contained in:
Torsten Schulz (local)
376
.output/server/chunks/build/auth-DIPdM0XJ.mjs
Normal file
376
.output/server/chunks/build/auth-DIPdM0XJ.mjs
Normal file
@@ -0,0 +1,376 @@
|
||||
import { A as executeAsync, E as hash } from '../nitro/nitro.mjs';
|
||||
import { e as defineNuxtRouteMiddleware, n as navigateTo, f as fetchDefaults, b as useNuxtApp, c as asyncDataDefaults, d as createError } from './server.mjs';
|
||||
import { computed, toValue, reactive, getCurrentInstance, onServerPrefetch, unref, ref, shallowRef, toRef, nextTick } from 'vue';
|
||||
import { isPlainObject } from '@vue/shared';
|
||||
import { debounce } from 'perfect-debounce';
|
||||
import 'node:http';
|
||||
import 'node:https';
|
||||
import 'node:events';
|
||||
import 'node:buffer';
|
||||
import 'node:fs';
|
||||
import 'node:path';
|
||||
import 'node:crypto';
|
||||
import 'node:url';
|
||||
import '../routes/renderer.mjs';
|
||||
import 'vue-bundle-renderer/runtime';
|
||||
import 'vue/server-renderer';
|
||||
import 'unhead/server';
|
||||
import 'devalue';
|
||||
import 'unhead/utils';
|
||||
import 'pinia';
|
||||
import 'vue-router';
|
||||
import 'lucide-vue-next';
|
||||
|
||||
function useAsyncData(...args) {
|
||||
const autoKey = typeof args[args.length - 1] === "string" ? args.pop() : void 0;
|
||||
if (_isAutoKeyNeeded(args[0], args[1])) {
|
||||
args.unshift(autoKey);
|
||||
}
|
||||
let [_key, _handler, options = {}] = args;
|
||||
const key = computed(() => toValue(_key));
|
||||
if (typeof key.value !== "string") {
|
||||
throw new TypeError("[nuxt] [useAsyncData] key must be a string.");
|
||||
}
|
||||
if (typeof _handler !== "function") {
|
||||
throw new TypeError("[nuxt] [useAsyncData] handler must be a function.");
|
||||
}
|
||||
const nuxtApp = useNuxtApp();
|
||||
options.server ??= true;
|
||||
options.default ??= getDefault;
|
||||
options.getCachedData ??= getDefaultCachedData;
|
||||
options.lazy ??= false;
|
||||
options.immediate ??= true;
|
||||
options.deep ??= asyncDataDefaults.deep;
|
||||
options.dedupe ??= "cancel";
|
||||
options._functionName || "useAsyncData";
|
||||
nuxtApp._asyncData[key.value];
|
||||
function createInitialFetch() {
|
||||
const initialFetchOptions = { cause: "initial", dedupe: options.dedupe };
|
||||
if (!nuxtApp._asyncData[key.value]?._init) {
|
||||
initialFetchOptions.cachedData = options.getCachedData(key.value, nuxtApp, { cause: "initial" });
|
||||
nuxtApp._asyncData[key.value] = createAsyncData(nuxtApp, key.value, _handler, options, initialFetchOptions.cachedData);
|
||||
}
|
||||
return () => nuxtApp._asyncData[key.value].execute(initialFetchOptions);
|
||||
}
|
||||
const initialFetch = createInitialFetch();
|
||||
const asyncData = nuxtApp._asyncData[key.value];
|
||||
asyncData._deps++;
|
||||
const fetchOnServer = options.server !== false && nuxtApp.payload.serverRendered;
|
||||
if (fetchOnServer && options.immediate) {
|
||||
const promise = initialFetch();
|
||||
if (getCurrentInstance()) {
|
||||
onServerPrefetch(() => promise);
|
||||
} else {
|
||||
nuxtApp.hook("app:created", async () => {
|
||||
await promise;
|
||||
});
|
||||
}
|
||||
}
|
||||
const asyncReturn = {
|
||||
data: writableComputedRef(() => nuxtApp._asyncData[key.value]?.data),
|
||||
pending: writableComputedRef(() => nuxtApp._asyncData[key.value]?.pending),
|
||||
status: writableComputedRef(() => nuxtApp._asyncData[key.value]?.status),
|
||||
error: writableComputedRef(() => nuxtApp._asyncData[key.value]?.error),
|
||||
refresh: (...args2) => {
|
||||
if (!nuxtApp._asyncData[key.value]?._init) {
|
||||
const initialFetch2 = createInitialFetch();
|
||||
return initialFetch2();
|
||||
}
|
||||
return nuxtApp._asyncData[key.value].execute(...args2);
|
||||
},
|
||||
execute: (...args2) => asyncReturn.refresh(...args2),
|
||||
clear: () => clearNuxtDataByKey(nuxtApp, key.value)
|
||||
};
|
||||
const asyncDataPromise = Promise.resolve(nuxtApp._asyncDataPromises[key.value]).then(() => asyncReturn);
|
||||
Object.assign(asyncDataPromise, asyncReturn);
|
||||
return asyncDataPromise;
|
||||
}
|
||||
function writableComputedRef(getter) {
|
||||
return computed({
|
||||
get() {
|
||||
return getter()?.value;
|
||||
},
|
||||
set(value) {
|
||||
const ref2 = getter();
|
||||
if (ref2) {
|
||||
ref2.value = value;
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
function _isAutoKeyNeeded(keyOrFetcher, fetcher) {
|
||||
if (typeof keyOrFetcher === "string") {
|
||||
return false;
|
||||
}
|
||||
if (typeof keyOrFetcher === "object" && keyOrFetcher !== null) {
|
||||
return false;
|
||||
}
|
||||
if (typeof keyOrFetcher === "function" && typeof fetcher === "function") {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
function clearNuxtDataByKey(nuxtApp, key) {
|
||||
if (key in nuxtApp.payload.data) {
|
||||
nuxtApp.payload.data[key] = void 0;
|
||||
}
|
||||
if (key in nuxtApp.payload._errors) {
|
||||
nuxtApp.payload._errors[key] = void 0;
|
||||
}
|
||||
if (nuxtApp._asyncData[key]) {
|
||||
nuxtApp._asyncData[key].data.value = unref(nuxtApp._asyncData[key]._default());
|
||||
nuxtApp._asyncData[key].error.value = void 0;
|
||||
nuxtApp._asyncData[key].status.value = "idle";
|
||||
}
|
||||
if (key in nuxtApp._asyncDataPromises) {
|
||||
if (nuxtApp._asyncDataPromises[key]) {
|
||||
nuxtApp._asyncDataPromises[key].cancelled = true;
|
||||
}
|
||||
nuxtApp._asyncDataPromises[key] = void 0;
|
||||
}
|
||||
}
|
||||
function pick(obj, keys) {
|
||||
const newObj = {};
|
||||
for (const key of keys) {
|
||||
newObj[key] = obj[key];
|
||||
}
|
||||
return newObj;
|
||||
}
|
||||
function createAsyncData(nuxtApp, key, _handler, options, initialCachedData) {
|
||||
nuxtApp.payload._errors[key] ??= void 0;
|
||||
const hasCustomGetCachedData = options.getCachedData !== getDefaultCachedData;
|
||||
const handler = _handler ;
|
||||
const _ref = options.deep ? ref : shallowRef;
|
||||
const hasCachedData = initialCachedData !== void 0;
|
||||
const unsubRefreshAsyncData = nuxtApp.hook("app:data:refresh", async (keys) => {
|
||||
if (!keys || keys.includes(key)) {
|
||||
await asyncData.execute({ cause: "refresh:hook" });
|
||||
}
|
||||
});
|
||||
const asyncData = {
|
||||
data: _ref(hasCachedData ? initialCachedData : options.default()),
|
||||
pending: computed(() => asyncData.status.value === "pending"),
|
||||
error: toRef(nuxtApp.payload._errors, key),
|
||||
status: shallowRef("idle"),
|
||||
execute: (...args) => {
|
||||
const [_opts, newValue = void 0] = args;
|
||||
const opts = _opts && newValue === void 0 && typeof _opts === "object" ? _opts : {};
|
||||
if (nuxtApp._asyncDataPromises[key]) {
|
||||
if ((opts.dedupe ?? options.dedupe) === "defer") {
|
||||
return nuxtApp._asyncDataPromises[key];
|
||||
}
|
||||
nuxtApp._asyncDataPromises[key].cancelled = true;
|
||||
}
|
||||
{
|
||||
const cachedData = "cachedData" in opts ? opts.cachedData : options.getCachedData(key, nuxtApp, { cause: opts.cause ?? "refresh:manual" });
|
||||
if (cachedData !== void 0) {
|
||||
nuxtApp.payload.data[key] = asyncData.data.value = cachedData;
|
||||
asyncData.error.value = void 0;
|
||||
asyncData.status.value = "success";
|
||||
return Promise.resolve(cachedData);
|
||||
}
|
||||
}
|
||||
asyncData.status.value = "pending";
|
||||
const promise = new Promise(
|
||||
(resolve, reject) => {
|
||||
try {
|
||||
resolve(handler(nuxtApp));
|
||||
} catch (err) {
|
||||
reject(err);
|
||||
}
|
||||
}
|
||||
).then(async (_result) => {
|
||||
if (promise.cancelled) {
|
||||
return nuxtApp._asyncDataPromises[key];
|
||||
}
|
||||
let result = _result;
|
||||
if (options.transform) {
|
||||
result = await options.transform(_result);
|
||||
}
|
||||
if (options.pick) {
|
||||
result = pick(result, options.pick);
|
||||
}
|
||||
nuxtApp.payload.data[key] = result;
|
||||
asyncData.data.value = result;
|
||||
asyncData.error.value = void 0;
|
||||
asyncData.status.value = "success";
|
||||
}).catch((error) => {
|
||||
if (promise.cancelled) {
|
||||
return nuxtApp._asyncDataPromises[key];
|
||||
}
|
||||
asyncData.error.value = createError(error);
|
||||
asyncData.data.value = unref(options.default());
|
||||
asyncData.status.value = "error";
|
||||
}).finally(() => {
|
||||
if (promise.cancelled) {
|
||||
return;
|
||||
}
|
||||
delete nuxtApp._asyncDataPromises[key];
|
||||
});
|
||||
nuxtApp._asyncDataPromises[key] = promise;
|
||||
return nuxtApp._asyncDataPromises[key];
|
||||
},
|
||||
_execute: debounce((...args) => asyncData.execute(...args), 0, { leading: true }),
|
||||
_default: options.default,
|
||||
_deps: 0,
|
||||
_init: true,
|
||||
_hash: void 0,
|
||||
_off: () => {
|
||||
unsubRefreshAsyncData();
|
||||
if (nuxtApp._asyncData[key]?._init) {
|
||||
nuxtApp._asyncData[key]._init = false;
|
||||
}
|
||||
if (!hasCustomGetCachedData) {
|
||||
nextTick(() => {
|
||||
if (!nuxtApp._asyncData[key]?._init) {
|
||||
clearNuxtDataByKey(nuxtApp, key);
|
||||
asyncData.execute = () => Promise.resolve();
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
};
|
||||
return asyncData;
|
||||
}
|
||||
const getDefault = () => void 0;
|
||||
const getDefaultCachedData = (key, nuxtApp, ctx) => {
|
||||
if (nuxtApp.isHydrating) {
|
||||
return nuxtApp.payload.data[key];
|
||||
}
|
||||
if (ctx.cause !== "refresh:manual" && ctx.cause !== "refresh:hook") {
|
||||
return nuxtApp.static.data[key];
|
||||
}
|
||||
};
|
||||
function useRequestEvent(nuxtApp) {
|
||||
nuxtApp ||= useNuxtApp();
|
||||
return nuxtApp.ssrContext?.event;
|
||||
}
|
||||
function useRequestFetch() {
|
||||
return useRequestEvent()?.$fetch || globalThis.$fetch;
|
||||
}
|
||||
function useFetch(request, arg1, arg2) {
|
||||
const [opts = {}, autoKey] = [{}, arg1];
|
||||
const _request = computed(() => toValue(request));
|
||||
const key = computed(() => toValue(opts.key) || "$f" + hash([autoKey, typeof _request.value === "string" ? _request.value : "", ...generateOptionSegments(opts)]));
|
||||
if (!opts.baseURL && typeof _request.value === "string" && (_request.value[0] === "/" && _request.value[1] === "/")) {
|
||||
throw new Error('[nuxt] [useFetch] the request URL must not start with "//".');
|
||||
}
|
||||
const {
|
||||
server,
|
||||
lazy,
|
||||
default: defaultFn,
|
||||
transform,
|
||||
pick: pick2,
|
||||
watch: watchSources,
|
||||
immediate,
|
||||
getCachedData,
|
||||
deep,
|
||||
dedupe,
|
||||
...fetchOptions
|
||||
} = opts;
|
||||
const _fetchOptions = reactive({
|
||||
...fetchDefaults,
|
||||
...fetchOptions,
|
||||
cache: typeof opts.cache === "boolean" ? void 0 : opts.cache
|
||||
});
|
||||
const _asyncDataOptions = {
|
||||
server,
|
||||
lazy,
|
||||
default: defaultFn,
|
||||
transform,
|
||||
pick: pick2,
|
||||
immediate,
|
||||
getCachedData,
|
||||
deep,
|
||||
dedupe,
|
||||
watch: watchSources === false ? [] : [...watchSources || [], _fetchOptions]
|
||||
};
|
||||
let controller;
|
||||
const asyncData = useAsyncData(watchSources === false ? key.value : key, () => {
|
||||
controller?.abort?.(new DOMException("Request aborted as another request to the same endpoint was initiated.", "AbortError"));
|
||||
controller = typeof AbortController !== "undefined" ? new AbortController() : {};
|
||||
const timeoutLength = toValue(opts.timeout);
|
||||
let timeoutId;
|
||||
if (timeoutLength) {
|
||||
timeoutId = setTimeout(() => controller.abort(new DOMException("Request aborted due to timeout.", "AbortError")), timeoutLength);
|
||||
controller.signal.onabort = () => clearTimeout(timeoutId);
|
||||
}
|
||||
let _$fetch = opts.$fetch || globalThis.$fetch;
|
||||
if (!opts.$fetch) {
|
||||
const isLocalFetch = typeof _request.value === "string" && _request.value[0] === "/" && (!toValue(opts.baseURL) || toValue(opts.baseURL)[0] === "/");
|
||||
if (isLocalFetch) {
|
||||
_$fetch = useRequestFetch();
|
||||
}
|
||||
}
|
||||
return _$fetch(_request.value, { signal: controller.signal, ..._fetchOptions }).finally(() => {
|
||||
clearTimeout(timeoutId);
|
||||
});
|
||||
}, _asyncDataOptions);
|
||||
return asyncData;
|
||||
}
|
||||
function generateOptionSegments(opts) {
|
||||
const segments = [
|
||||
toValue(opts.method)?.toUpperCase() || "GET",
|
||||
toValue(opts.baseURL)
|
||||
];
|
||||
for (const _obj of [opts.params || opts.query]) {
|
||||
const obj = toValue(_obj);
|
||||
if (!obj) {
|
||||
continue;
|
||||
}
|
||||
const unwrapped = {};
|
||||
for (const [key, value] of Object.entries(obj)) {
|
||||
unwrapped[toValue(key)] = toValue(value);
|
||||
}
|
||||
segments.push(unwrapped);
|
||||
}
|
||||
if (opts.body) {
|
||||
const value = toValue(opts.body);
|
||||
if (!value) {
|
||||
segments.push(hash(value));
|
||||
} else if (value instanceof ArrayBuffer) {
|
||||
segments.push(hash(Object.fromEntries([...new Uint8Array(value).entries()].map(([k, v]) => [k, v.toString()]))));
|
||||
} else if (value instanceof FormData) {
|
||||
const obj = {};
|
||||
for (const entry of value.entries()) {
|
||||
const [key, val] = entry;
|
||||
obj[key] = val instanceof File ? val.name : val;
|
||||
}
|
||||
segments.push(hash(obj));
|
||||
} else if (isPlainObject(value)) {
|
||||
segments.push(hash(reactive(value)));
|
||||
} else {
|
||||
try {
|
||||
segments.push(hash(value));
|
||||
} catch {
|
||||
console.warn("[useFetch] Failed to hash body", value);
|
||||
}
|
||||
}
|
||||
}
|
||||
return segments;
|
||||
}
|
||||
const auth = defineNuxtRouteMiddleware(async (to, from) => {
|
||||
let __temp, __restore;
|
||||
const protectedRoutes = ["/mitgliederbereich", "/cms"];
|
||||
const requiresAuth = protectedRoutes.some((route) => to.path.startsWith(route));
|
||||
if (!requiresAuth) {
|
||||
return;
|
||||
}
|
||||
try {
|
||||
const { data: auth2 } = ([__temp, __restore] = executeAsync(() => useFetch("/api/auth/status", "$iafshigZRx")), __temp = await __temp, __restore(), __temp);
|
||||
if (!auth2.value || !auth2.value.isLoggedIn) {
|
||||
return navigateTo("/login?redirect=" + to.path);
|
||||
}
|
||||
if (to.path.startsWith("/cms")) {
|
||||
const isAdmin = auth2.value.role === "admin" || auth2.value.role === "vorstand";
|
||||
if (!isAdmin) {
|
||||
return navigateTo("/mitgliederbereich");
|
||||
}
|
||||
}
|
||||
} catch (error) {
|
||||
return navigateTo("/login?redirect=" + to.path);
|
||||
}
|
||||
});
|
||||
|
||||
export { auth as default };
|
||||
//# sourceMappingURL=auth-DIPdM0XJ.mjs.map
|
||||
Reference in New Issue
Block a user