keycloakify
Version:
Framework to create custom Keycloak UIs
1,295 lines (1,213 loc) • 104 kB
JavaScript
"use strict";
exports.id = 375;
exports.ids = [375];
exports.modules = {
/***/ 64097:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
// ESM COMPAT FLAG
__webpack_require__.r(__webpack_exports__);
// EXPORTS
__webpack_require__.d(__webpack_exports__, {
"command": () => (/* reexport */ command)
});
// EXTERNAL MODULE: ./node_modules/tsafe/esm/exclude.mjs
var exclude = __webpack_require__(83101);
// EXTERNAL MODULE: ./dist/bin/shared/constants.js
var constants = __webpack_require__(173);
// EXTERNAL MODULE: ./dist/bin/tools/SemVer.js
var SemVer = __webpack_require__(12171);
// EXTERNAL MODULE: ./node_modules/tsafe/esm/assert.mjs + 1 modules
var assert = __webpack_require__(29041);
// EXTERNAL MODULE: external "fs"
var external_fs_ = __webpack_require__(57147);
var external_fs_default = /*#__PURE__*/__webpack_require__.n(external_fs_);
// EXTERNAL MODULE: external "path"
var external_path_ = __webpack_require__(71017);
// EXTERNAL MODULE: external "child_process"
var external_child_process_ = __webpack_require__(32081);
var external_child_process_default = /*#__PURE__*/__webpack_require__.n(external_child_process_);
// EXTERNAL MODULE: ./node_modules/chalk/source/index.js
var source = __webpack_require__(78818);
var source_default = /*#__PURE__*/__webpack_require__.n(source);
// EXTERNAL MODULE: ./node_modules/chokidar/index.js
var chokidar = __webpack_require__(42677);
// EXTERNAL MODULE: ./node_modules/powerhooks/tools/waitForDebounce.js
var tools_waitForDebounce = __webpack_require__(18721);
// EXTERNAL MODULE: ./dist/bin/tools/getThisCodebaseRootDirPath.js
var getThisCodebaseRootDirPath = __webpack_require__(58822);
// EXTERNAL MODULE: ./dist/bin/tools/getAbsoluteAndInOsFormatPath.js
var getAbsoluteAndInOsFormatPath = __webpack_require__(84794);
// EXTERNAL MODULE: ./node_modules/cli-select/dist/index.js
var dist = __webpack_require__(99398);
var dist_default = /*#__PURE__*/__webpack_require__.n(dist);
// EXTERNAL MODULE: ./node_modules/run-exclusive/lib/runExclusive.js
var runExclusive = __webpack_require__(81708);
// EXTERNAL MODULE: external "fs/promises"
var promises_ = __webpack_require__(73292);
var promises_default = /*#__PURE__*/__webpack_require__.n(promises_);
// EXTERNAL MODULE: ./node_modules/yauzl/index.js
var yauzl = __webpack_require__(78781);
// EXTERNAL MODULE: external "stream"
var external_stream_ = __webpack_require__(12781);
var external_stream_default = /*#__PURE__*/__webpack_require__.n(external_stream_);
// EXTERNAL MODULE: ./node_modules/evt/tools/Deferred.js
var Deferred = __webpack_require__(50689);
// EXTERNAL MODULE: ./dist/bin/tools/fs.existsAsync.js
var fs_existsAsync = __webpack_require__(43765);
;// CONCATENATED MODULE: ./dist/bin/tools/extractArchive.js
async function extractArchive(params) {
const { archiveFilePath, onArchiveFile } = params;
const zipFile = await new Promise((resolve, reject) => {
yauzl.open(archiveFilePath, { lazyEntries: true }, async (error, zipFile) => {
if (error) {
reject(error);
return;
}
resolve(zipFile);
});
});
const dDone = new Deferred.Deferred();
zipFile.once("end", () => {
zipFile.close();
dDone.resolve();
});
const writeFile = async (entry, params) => {
const { filePath, modifiedData } = params;
{
const dirPath = (0,external_path_.dirname)(filePath);
if (!(await (0,fs_existsAsync/* existsAsync */.o)(dirPath))) {
await promises_default().mkdir(dirPath, { recursive: true });
}
}
if (modifiedData !== undefined) {
await promises_default().writeFile(filePath, modifiedData);
return;
}
const readStream = await new Promise(resolve => zipFile.openReadStream(entry, async (error, readStream) => {
if (error) {
dDone.reject(error);
return;
}
resolve(readStream);
}));
const dDoneWithFile = new Deferred.Deferred();
external_stream_default().pipeline(readStream, external_fs_default().createWriteStream(filePath), error => {
if (error) {
dDone.reject(error);
return;
}
dDoneWithFile.resolve();
});
await dDoneWithFile.pr;
};
const readFile = (entry) => new Promise(resolve => zipFile.openReadStream(entry, async (error, readStream) => {
if (error) {
dDone.reject(error);
return;
}
const chunks = [];
readStream.on("data", chunk => {
chunks.push(chunk);
});
readStream.on("end", () => {
resolve(Buffer.concat(chunks));
});
readStream.on("error", error => {
dDone.reject(error);
});
}));
zipFile.on("entry", async (entry) => {
handle_file: {
// NOTE: Skip directories
if (entry.fileName.endsWith("/")) {
break handle_file;
}
let hasEarlyExitBeenCalled = false;
await onArchiveFile({
relativeFilePathInArchive: entry.fileName.split("/").join(external_path_.sep),
readFile: () => readFile(entry),
writeFile: params => writeFile(entry, params),
earlyExit: () => {
hasEarlyExitBeenCalled = true;
}
});
if (hasEarlyExitBeenCalled) {
zipFile.close();
dDone.resolve();
return;
}
}
zipFile.readEntry();
});
zipFile.readEntry();
await dDone.pr;
}
//# sourceMappingURL=extractArchive.js.map
// EXTERNAL MODULE: ./node_modules/tsafe/esm/id.mjs
var id = __webpack_require__(38469);
// EXTERNAL MODULE: ./node_modules/zod/lib/index.mjs
var lib = __webpack_require__(52300);
;// CONCATENATED MODULE: ./dist/bin/start-keycloak/appBuild.js
(0,assert/* assert */.h)();
async function appBuild(params) {
var _a;
const { buildContext } = params;
const { parsedPackageJson } = (() => {
const zParsedPackageJson = (() => {
const zTargetType = lib.z.object({
scripts: lib.z.record(lib.z.string()).optional()
});
(0,assert/* assert */.h)();
return (0,id.id)(zTargetType);
})();
const parsedPackageJson = JSON.parse(external_fs_.readFileSync(buildContext.packageJsonFilePath).toString("utf8"));
zParsedPackageJson.parse(parsedPackageJson);
(0,assert/* assert */.h)((0,assert.is)(parsedPackageJson));
return { parsedPackageJson };
})();
const entries = Object.entries((_a = parsedPackageJson.scripts) !== null && _a !== void 0 ? _a : {}).filter(([, scriptCommand]) => scriptCommand.includes("keycloakify build"));
if (entries.length === 0) {
console.log(source_default().red([
`You should have a script in your package.json at ${(0,external_path_.relative)(process.cwd(), (0,external_path_.dirname)(buildContext.packageJsonFilePath))}`,
`that includes the 'keycloakify build' command`
].join(" ")));
process.exit(-1);
}
const entry = entries.length === 1
? entries[0]
: entries.find(([scriptName]) => scriptName === "build-keycloak-theme");
if (entry === undefined) {
console.log(source_default().red("There's multiple candidate script for building your app, name one 'build-keycloak-theme'"));
process.exit(-1);
}
const [scriptName, scriptCommand] = entry;
const { appBuildSubCommands } = (() => {
const appBuildSubCommands = [];
for (const subCmd of scriptCommand.split("&&").map(s => s.trim())) {
if (subCmd.includes("keycloakify build")) {
break;
}
appBuildSubCommands.push(subCmd);
}
return { appBuildSubCommands };
})();
if (appBuildSubCommands.length === 0) {
console.log(source_default().red(`Your ${scriptName} script should look like "... && keycloakify build ..."`));
process.exit(-1);
}
common_case: {
if (appBuildSubCommands.length !== 1) {
break common_case;
}
const [appBuildSubCommand] = appBuildSubCommands;
const isNpmRunBuild = (() => {
for (const packageManager of ["npm", "yarn", "pnpm", "bun", "deno"]) {
for (const doUseRun of [true, false]) {
if (`${packageManager}${doUseRun ? " run " : " "}build` ===
appBuildSubCommand) {
return true;
}
}
}
return false;
})();
if (!isNpmRunBuild) {
break common_case;
}
const { scripts } = parsedPackageJson;
(0,assert/* assert */.h)(scripts !== undefined);
const buildCmd = scripts.build;
if (buildCmd !== "tsc && vite build") {
break common_case;
}
if (scripts.prebuild !== undefined) {
break common_case;
}
if (scripts.postbuild !== undefined) {
break common_case;
}
const dIsSuccess = new Deferred.Deferred();
console.log(source_default().blue("$ npx vite build"));
const child = external_child_process_.spawn("npx", ["vite", "build"], {
cwd: buildContext.projectDirPath,
shell: true
});
child.stdout.on("data", data => {
if (data.toString("utf8").includes("gzip:")) {
return;
}
process.stdout.write(data);
});
child.stderr.on("data", data => process.stderr.write(data));
child.on("exit", code => dIsSuccess.resolve(code === 0));
const isSuccess = await dIsSuccess.pr;
return { isAppBuildSuccess: isSuccess };
}
let commandCwd = (0,external_path_.dirname)(buildContext.packageJsonFilePath);
for (const subCommand of appBuildSubCommands) {
const dIsSuccess = new Deferred.Deferred();
const [command, ...args] = subCommand.split(" ");
if (command === "cd") {
const [pathIsh] = args;
commandCwd = (0,getAbsoluteAndInOsFormatPath/* getAbsoluteAndInOsFormatPath */.c)({
pathIsh,
cwd: commandCwd
});
continue;
}
console.log(source_default().blue(`$ ${subCommand}`));
const child = external_child_process_.spawn(command, args, {
cwd: commandCwd,
env: Object.assign(Object.assign({}, process.env), { PATH: (() => {
var _a;
const separator = external_path_.sep === "/" ? ":" : ";";
return [
(0,external_path_.join)((0,external_path_.dirname)(buildContext.packageJsonFilePath), "node_modules", ".bin"),
...((_a = process.env.PATH) !== null && _a !== void 0 ? _a : "").split(separator)
].join(separator);
})() }),
shell: true
});
child.stdout.on("data", data => process.stdout.write(data));
child.stderr.on("data", data => process.stderr.write(data));
child.on("exit", code => dIsSuccess.resolve(code === 0));
const isSuccess = await dIsSuccess.pr;
if (!isSuccess) {
return { isAppBuildSuccess: false };
}
}
return { isAppBuildSuccess: true };
}
//# sourceMappingURL=appBuild.js.map
;// CONCATENATED MODULE: ./dist/bin/start-keycloak/keycloakifyBuild.js
(0,assert/* assert */.h)();
async function keycloakifyBuild(params) {
const { buildForKeycloakMajorVersionNumber, buildContext } = params;
const dResult = new Deferred.Deferred();
console.log(source_default().blue("$ npx keycloakify build"));
const child = external_child_process_.spawn("npx", ["keycloakify", "build"], {
cwd: buildContext.projectDirPath,
env: Object.assign(Object.assign({}, process.env), { [constants/* BUILD_FOR_KEYCLOAK_MAJOR_VERSION_ENV_NAME */.ac]: `${buildForKeycloakMajorVersionNumber}` }),
shell: true
});
child.stdout.on("data", data => process.stdout.write(data));
child.stderr.on("data", data => process.stderr.write(data));
child.on("exit", code => dResult.resolve({ isSuccess: code === 0 }));
const { isSuccess } = await dResult.pr;
return { isKeycloakifyBuildSuccess: isSuccess };
}
//# sourceMappingURL=keycloakifyBuild.js.map
// EXTERNAL MODULE: ./dist/bin/tools/isInside.js
var isInside = __webpack_require__(90665);
;// CONCATENATED MODULE: ./dist/bin/tools/fs.rm.js
/**
* Polyfill of fs.rm(dirPath, { "recursive": true })
* For older version of Node
*/
async function rm(dirPath, options) {
if (SemVer/* SemVer.compare */.h.compare(SemVer/* SemVer.parse */.h.parse(process.version), SemVer/* SemVer.parse */.h.parse("14.14.0")) > 0) {
return promises_.rm(dirPath, options);
}
const { force = true } = options;
if (force && !(await checkDirExists(dirPath))) {
return;
}
const removeDir_rec = async (dirPath) => Promise.all((await promises_.readdir(dirPath)).map(async (basename) => {
const fileOrDirpath = (0,external_path_.join)(dirPath, basename);
if ((await promises_.lstat(fileOrDirpath)).isDirectory()) {
await removeDir_rec(fileOrDirpath);
}
else {
await promises_.unlink(fileOrDirpath);
}
}));
await removeDir_rec(dirPath);
}
async function checkDirExists(dirPath) {
try {
await promises_.access(dirPath, promises_.constants.F_OK);
return true;
}
catch (_a) {
return false;
}
}
//# sourceMappingURL=fs.rm.js.map
// EXTERNAL MODULE: ./node_modules/make-fetch-happen/lib/index.js
var make_fetch_happen_lib = __webpack_require__(9525);
var lib_default = /*#__PURE__*/__webpack_require__.n(make_fetch_happen_lib);
// EXTERNAL MODULE: external "crypto"
var external_crypto_ = __webpack_require__(6113);
;// CONCATENATED MODULE: ./dist/bin/tools/downloadAndExtractArchive.js
async function downloadAndExtractArchive(params) {
var _a;
const { url, uniqueIdOfOnArchiveFile, onArchiveFile, cacheDirPath, fetchOptions } = params;
const archiveFileBasename = url.split("?")[0].split("/").reverse()[0];
const archiveFilePath = (0,external_path_.join)(cacheDirPath, archiveFileBasename);
download: {
await (0,promises_.mkdir)((0,external_path_.dirname)(archiveFilePath), { recursive: true });
if (await (0,fs_existsAsync/* existsAsync */.o)(archiveFilePath)) {
const isDownloaded = await SuccessTracker.getIsDownloaded({
cacheDirPath,
archiveFileBasename
});
if (isDownloaded) {
break download;
}
await (0,promises_.unlink)(archiveFilePath);
await SuccessTracker.removeFromDownloaded({
cacheDirPath,
archiveFileBasename
});
}
const response = await lib_default()(url, fetchOptions);
(_a = response.body) === null || _a === void 0 ? void 0 : _a.setMaxListeners(Number.MAX_VALUE);
(0,assert/* assert */.h)(typeof response.body !== "undefined" && response.body != null);
await (0,promises_.writeFile)(archiveFilePath, response.body);
await SuccessTracker.markAsDownloaded({
cacheDirPath,
archiveFileBasename
});
}
const extractDirBasename = `${archiveFileBasename.replace(/\.([^.]+)$/, (...[, ext]) => `_${ext}`)}_${uniqueIdOfOnArchiveFile}_${external_crypto_.createHash("sha256")
.update(onArchiveFile.toString())
.digest("hex")
.substring(0, 5)}`;
await Promise.all((await (0,promises_.readdir)(cacheDirPath))
.filter((() => {
const prefix = extractDirBasename
.split("_")
.reverse()
.slice(1)
.reverse()
.join("_");
return basename => basename !== extractDirBasename && basename.startsWith(prefix);
})())
.map(async (extractDirBasename) => {
await rm((0,external_path_.join)(cacheDirPath, extractDirBasename), {
recursive: true
});
await SuccessTracker.removeFromExtracted({
cacheDirPath,
extractDirBasename
});
}));
const extractedDirPath = (0,external_path_.join)(cacheDirPath, extractDirBasename);
extract_and_transform: {
if (await (0,fs_existsAsync/* existsAsync */.o)(extractedDirPath)) {
const isExtracted = await SuccessTracker.getIsExtracted({
cacheDirPath,
extractDirBasename
});
if (isExtracted) {
break extract_and_transform;
}
await rm(extractedDirPath, { recursive: true });
await SuccessTracker.removeFromExtracted({
cacheDirPath,
extractDirBasename
});
}
await extractArchive({
archiveFilePath,
onArchiveFile: async ({ relativeFilePathInArchive, readFile, writeFile }) => onArchiveFile({
fileRelativePath: relativeFilePathInArchive,
readFile,
writeFile: ({ fileRelativePath, modifiedData }) => writeFile({
filePath: (0,external_path_.join)(extractedDirPath, fileRelativePath),
modifiedData
})
})
});
await SuccessTracker.markAsExtracted({
cacheDirPath,
extractDirBasename
});
}
return { extractedDirPath, archiveFilePath };
}
var SuccessTracker;
(function (SuccessTracker) {
async function read(params) {
const { cacheDirPath } = params;
const filePath = (0,external_path_.join)(cacheDirPath, "downloadAndExtractArchive.json");
if (!(await (0,fs_existsAsync/* existsAsync */.o)(filePath))) {
return { archiveFileBasenames: [], extractDirBasenames: [] };
}
return JSON.parse((await (0,promises_.readFile)(filePath)).toString("utf8"));
}
async function write(params) {
const { cacheDirPath, successTracker } = params;
const filePath = (0,external_path_.join)(cacheDirPath, "downloadAndExtractArchive.json");
{
const dirPath = (0,external_path_.dirname)(filePath);
if (!(await (0,fs_existsAsync/* existsAsync */.o)(dirPath))) {
await (0,promises_.mkdir)(dirPath, { recursive: true });
}
}
await (0,promises_.writeFile)(filePath, JSON.stringify(successTracker));
}
async function markAsDownloaded(params) {
const { cacheDirPath, archiveFileBasename } = params;
const successTracker = await read({ cacheDirPath });
successTracker.archiveFileBasenames.push(archiveFileBasename);
await write({ cacheDirPath, successTracker });
}
SuccessTracker.markAsDownloaded = markAsDownloaded;
async function getIsDownloaded(params) {
const { cacheDirPath, archiveFileBasename } = params;
const successTracker = await read({ cacheDirPath });
return successTracker.archiveFileBasenames.includes(archiveFileBasename);
}
SuccessTracker.getIsDownloaded = getIsDownloaded;
async function removeFromDownloaded(params) {
const { cacheDirPath, archiveFileBasename } = params;
const successTracker = await read({ cacheDirPath });
successTracker.archiveFileBasenames = successTracker.archiveFileBasenames.filter(basename => basename !== archiveFileBasename);
await write({ cacheDirPath, successTracker });
}
SuccessTracker.removeFromDownloaded = removeFromDownloaded;
async function markAsExtracted(params) {
const { cacheDirPath, extractDirBasename } = params;
const successTracker = await read({ cacheDirPath });
successTracker.extractDirBasenames.push(extractDirBasename);
await write({ cacheDirPath, successTracker });
}
SuccessTracker.markAsExtracted = markAsExtracted;
async function getIsExtracted(params) {
const { cacheDirPath, extractDirBasename } = params;
const successTracker = await read({ cacheDirPath });
return successTracker.extractDirBasenames.includes(extractDirBasename);
}
SuccessTracker.getIsExtracted = getIsExtracted;
async function removeFromExtracted(params) {
const { cacheDirPath, extractDirBasename } = params;
const successTracker = await read({ cacheDirPath });
successTracker.extractDirBasenames = successTracker.extractDirBasenames.filter(basename => basename !== extractDirBasename);
await write({ cacheDirPath, successTracker });
}
SuccessTracker.removeFromExtracted = removeFromExtracted;
})(SuccessTracker || (SuccessTracker = {}));
//# sourceMappingURL=downloadAndExtractArchive.js.map
;// CONCATENATED MODULE: ./dist/bin/start-keycloak/startViteDevServer.js
(0,assert/* assert */.h)();
function startViteDevServer(params) {
const { buildContext } = params;
console.log(source_default().blue(`$ npx vite dev`));
const child = external_child_process_.spawn("npx", ["vite", "dev"], {
cwd: buildContext.projectDirPath,
env: Object.assign(Object.assign({}, process.env), { [constants/* VITE_PLUGIN_SUB_SCRIPTS_ENV_NAMES.READ_KC_CONTEXT_FROM_URL */.TE.READ_KC_CONTEXT_FROM_URL]: "true" }),
shell: true
});
child.stdout.on("data", data => {
if (!data.toString("utf8").includes("[vite] hmr")) {
return;
}
process.stdout.write(data);
});
child.stderr.on("data", data => process.stderr.write(data));
const dPort = new Deferred.Deferred();
{
const onData = (data) => {
//Local: http://localhost:8083/
const match = data
.toString("utf8")
.replace(/\x1b[[0-9;]*m/g, "")
.match(/Local:\s*http:\/\/(?:localhost|127\.0\.0\.1):(\d+)\//);
if (match === null) {
return;
}
child.stdout.off("data", onData);
const port = parseInt(match[1]);
(0,assert/* assert */.h)(!isNaN(port));
dPort.resolve(port);
};
child.stdout.on("data", onData);
}
return dPort.pr.then(port => ({ port }));
}
//# sourceMappingURL=startViteDevServer.js.map
// EXTERNAL MODULE: ./node_modules/tsafe/esm/is.mjs
var is = __webpack_require__(16453);
;// CONCATENATED MODULE: ./dist/bin/start-keycloak/realmConfig/ParsedRealmJson/ParsedRealmJson.js
const zParsedRealmJson = (() => {
const zTargetType = lib.z.object({
realm: lib.z.string(),
loginTheme: lib.z.string().optional(),
accountTheme: lib.z.string().optional(),
adminTheme: lib.z.string().optional(),
emailTheme: lib.z.string().optional(),
sslRequired: lib.z.string().optional(),
eventsListeners: lib.z.array(lib.z.string()),
users: lib.z.array(lib.z.object({
id: lib.z.string(),
email: lib.z.string(),
username: lib.z.string(),
credentials: lib.z.array(lib.z.object({
type: lib.z.string()
})),
clientRoles: lib.z.record(lib.z.array(lib.z.string())).optional()
})),
roles: lib.z.object({
client: lib.z.record(lib.z.array(lib.z.object({
name: lib.z.string(),
containerId: lib.z.string()
})))
}),
clients: lib.z.array(lib.z.object({
id: lib.z.string(),
clientId: lib.z.string(),
baseUrl: lib.z.string().optional(),
redirectUris: lib.z.array(lib.z.string()).optional(),
webOrigins: lib.z.array(lib.z.string()).optional(),
attributes: lib.z.object({
"post.logout.redirect.uris": lib.z.string().optional()
})
.optional(),
protocol: lib.z.string().optional(),
protocolMappers: lib.z.array(lib.z.object({
id: lib.z.string(),
name: lib.z.string(),
protocol: lib.z.string(),
protocolMapper: lib.z.string(),
consentRequired: lib.z.boolean(),
config: lib.z.record(lib.z.string()).optional()
}))
.optional()
}))
});
assert/* assert */.h;
return (0,id.id)(zTargetType);
})();
//# sourceMappingURL=ParsedRealmJson.js.map
;// CONCATENATED MODULE: ./dist/bin/start-keycloak/realmConfig/ParsedRealmJson/readRealmJsonFile.js
function readRealmJsonFile(params) {
const { realmJsonFilePath } = params;
const parsedRealmJson = JSON.parse(external_fs_.readFileSync(realmJsonFilePath).toString("utf8"));
zParsedRealmJson.parse(parsedRealmJson);
(0,assert/* assert */.h)((0,is.is)(parsedRealmJson));
return parsedRealmJson;
}
//# sourceMappingURL=readRealmJsonFile.js.map
;// CONCATENATED MODULE: ./dist/bin/start-keycloak/realmConfig/defaultConfig/defaultConfig.js
function getDefaultRealmJsonFilePath(params) {
const { keycloakMajorVersionNumber } = params;
return (0,external_path_.join)((0,getThisCodebaseRootDirPath/* getThisCodebaseRootDirPath */.e)(), "src", "bin", "start-keycloak", "realmConfig", "defaultConfig", `realm-kc-${keycloakMajorVersionNumber}.json`);
}
const { getSupportedKeycloakMajorVersions } = (() => {
let cache = undefined;
function getSupportedKeycloakMajorVersions() {
if (cache !== undefined) {
return cache;
}
cache = external_fs_.readdirSync((0,external_path_.dirname)(getDefaultRealmJsonFilePath({ keycloakMajorVersionNumber: 0 })))
.map(fileBasename => {
const match = fileBasename.match(/^realm-kc-(\d+)\.json$/);
if (match === null) {
return undefined;
}
const n = parseInt(match[1]);
(0,assert/* assert */.h)(!isNaN(n));
return n;
})
.filter((0,exclude/* exclude */.D)(undefined))
.sort((a, b) => b - a);
return cache;
}
return { getSupportedKeycloakMajorVersions };
})();
function getDefaultConfig(params) {
const { keycloakMajorVersionNumber } = params;
(0,assert/* assert */.h)(getSupportedKeycloakMajorVersions().includes(keycloakMajorVersionNumber), `We do not have a default config for Keycloak ${keycloakMajorVersionNumber}`);
return readRealmJsonFile({
realmJsonFilePath: getDefaultRealmJsonFilePath({
keycloakMajorVersionNumber
})
});
}
//# sourceMappingURL=defaultConfig.js.map
;// CONCATENATED MODULE: ./dist/bin/start-keycloak/realmConfig/defaultConfig/index.js
//# sourceMappingURL=index.js.map
// EXTERNAL MODULE: ./dist/bin/tools/readThisNpmPackageVersion.js
var readThisNpmPackageVersion = __webpack_require__(64795);
;// CONCATENATED MODULE: ./dist/bin/start-keycloak/getSupportedDockerImageTags.js
assert/* assert */.h;
async function getSupportedDockerImageTags(params) {
const { buildContext } = params;
{
const result = await getCachedValue({ cacheDirPath: buildContext.cacheDirPath });
if (result !== undefined) {
return result;
}
}
const tags_queryResponse = [];
await (async function callee(url) {
const r = await lib_default()(url, buildContext.fetchOptions);
await Promise.all([
(async () => {
tags_queryResponse.push(...lib.z.object({
tags: lib.z.array(lib.z.string())
})
.parse(await r.json()).tags);
})(),
(async () => {
const link = r.headers.get("link");
if (link === null) {
return;
}
const split = link.split(";").map(s => s.trim());
(0,assert/* assert */.h)(split.length === 2);
(0,assert/* assert */.h)(split[1] === 'rel="next"');
const match = split[0].match(/^<(.+)>$/);
(0,assert/* assert */.h)(match !== null);
const nextUrl = new URL(url).origin + match[1];
await callee(nextUrl);
})()
]);
})("https://quay.io/v2/keycloak/keycloak/tags/list");
const supportedKeycloakMajorVersions = getSupportedKeycloakMajorVersions();
const allSupportedTags_withVersion = tags_queryResponse
.map(tag => ({
tag,
version: (() => {
if (tag.includes("-")) {
return undefined;
}
let version;
try {
version = SemVer/* SemVer.parse */.h.parse(tag);
}
catch (_a) {
return undefined;
}
if (tag.split(".").length !== 3) {
return undefined;
}
if (!supportedKeycloakMajorVersions.includes(version.major)) {
return undefined;
}
return version;
})()
}))
.map(({ tag, version }) => (version === undefined ? undefined : { tag, version }))
.filter((0,exclude/* exclude */.D)(undefined))
.sort(({ version: a }, { version: b }) => SemVer/* SemVer.compare */.h.compare(b, a));
const latestTagByMajor = {};
for (const { version } of allSupportedTags_withVersion) {
const version_current = latestTagByMajor[version.major];
if (version_current === undefined ||
SemVer/* SemVer.compare */.h.compare(version_current, version) === -1) {
latestTagByMajor[version.major] = version;
}
}
const latestMajorTags = Object.entries(latestTagByMajor)
.sort(([a], [b]) => parseInt(b) - parseInt(a))
.map(([, version]) => version)
.map(version => {
(0,assert/* assert */.h)(version !== undefined);
if (!supportedKeycloakMajorVersions.includes(version.major)) {
return undefined;
}
return SemVer/* SemVer.stringify */.h.stringify(version);
})
.filter((0,exclude/* exclude */.D)(undefined));
const allSupportedTags = allSupportedTags_withVersion.map(({ tag }) => tag);
const result = {
latestMajorTags,
allSupportedTags
};
await setCachedValue({ cacheDirPath: buildContext.cacheDirPath, result });
return result;
}
const { getCachedValue, setCachedValue } = (() => {
const zResult = (() => {
const zTargetType = lib.z.object({
allSupportedTags: lib.z.array(lib.z.string()),
latestMajorTags: lib.z.array(lib.z.string())
});
assert/* assert */.h;
return (0,id.id)(zTargetType);
})();
const zCache = (() => {
const zTargetType = lib.z.object({
keycloakifyVersion: lib.z.string(),
time: lib.z.number(),
result: zResult
});
assert/* assert */.h;
return (0,id.id)(zTargetType);
})();
let inMemoryCachedResult = undefined;
function getCacheFilePath(params) {
const { cacheDirPath } = params;
return (0,external_path_.join)(cacheDirPath, "supportedDockerImageTags.json");
}
async function getCachedValue(params) {
const { cacheDirPath } = params;
if (inMemoryCachedResult !== undefined) {
return inMemoryCachedResult;
}
const cacheFilePath = getCacheFilePath({ cacheDirPath });
if (!(await (0,fs_existsAsync/* existsAsync */.o)(cacheFilePath))) {
return undefined;
}
let cache;
try {
cache = zCache.parse(JSON.parse(await promises_.readFile(cacheFilePath, "utf8")));
}
catch (_a) {
return undefined;
}
if (cache.keycloakifyVersion !== (0,readThisNpmPackageVersion/* readThisNpmPackageVersion */.K)()) {
return undefined;
}
if (Date.now() - cache.time > 3600 * 24) {
return undefined;
}
inMemoryCachedResult = cache.result;
return cache.result;
}
async function setCachedValue(params) {
const { cacheDirPath, result } = params;
inMemoryCachedResult = result;
const cacheFilePath = getCacheFilePath({ cacheDirPath });
{
const dirPath = (0,external_path_.dirname)(cacheFilePath);
if (!(await (0,fs_existsAsync/* existsAsync */.o)(dirPath))) {
await promises_.mkdir(dirPath, { recursive: true });
}
}
await promises_.writeFile(cacheFilePath, JSON.stringify(zCache.parse({
keycloakifyVersion: (0,readThisNpmPackageVersion/* readThisNpmPackageVersion */.K)(),
time: Date.now(),
result
}), null, 2));
}
return {
getCachedValue,
setCachedValue
};
})();
//# sourceMappingURL=getSupportedDockerImageTags.js.map
// EXTERNAL MODULE: ./node_modules/evt/tools/inDepth/same.js
var same = __webpack_require__(33805);
;// CONCATENATED MODULE: ./dist/bin/start-keycloak/realmConfig/prepareRealmConfig.js
function prepareRealmConfig(params) {
const { parsedRealmJson, keycloakMajorVersionNumber, parsedKeycloakThemesJsonEntry } = params;
const { username } = addOrEditTestUser({
parsedRealmJson,
keycloakMajorVersionNumber
});
const { clientId } = addOrEditClient({
parsedRealmJson,
keycloakMajorVersionNumber
});
editAccountConsoleAndSecurityAdminConsole({ parsedRealmJson });
enableCustomThemes({
parsedRealmJson,
parsedKeycloakThemesJsonEntry
});
enable_custom_events_listeners: {
const name = "keycloakify-logging";
if (parsedRealmJson.eventsListeners.includes(name)) {
break enable_custom_events_listeners;
}
parsedRealmJson.eventsListeners.push(name);
parsedRealmJson.eventsListeners.sort();
}
parsedRealmJson.sslRequired = "none";
return {
realmName: parsedRealmJson.realm,
clientName: clientId,
username
};
}
function enableCustomThemes(params) {
const { parsedRealmJson, parsedKeycloakThemesJsonEntry } = params;
for (const themeType of [...constants/* THEME_TYPES */.Jh, "email"]) {
parsedRealmJson[`${themeType}Theme`] =
!parsedKeycloakThemesJsonEntry.types.includes(themeType)
? ""
: parsedKeycloakThemesJsonEntry.name;
}
}
function addOrEditTestUser(params) {
var _a, _b, _c, _d;
const { parsedRealmJson, keycloakMajorVersionNumber } = params;
const parsedRealmJson_default = getDefaultConfig({ keycloakMajorVersionNumber });
const [defaultUser_default] = parsedRealmJson_default.users;
(0,assert/* assert */.h)(defaultUser_default !== undefined);
const defaultUser_preexisting = parsedRealmJson.users.find(user => user.username === defaultUser_default.username);
const newUser = structuredClone((_a = defaultUser_preexisting !== null && defaultUser_preexisting !== void 0 ? defaultUser_preexisting : (() => {
const firstUser = parsedRealmJson.users[0];
if (firstUser === undefined) {
return undefined;
}
const firstUserCopy = structuredClone(firstUser);
firstUserCopy.id = defaultUser_default.id;
return firstUserCopy;
})()) !== null && _a !== void 0 ? _a : defaultUser_default);
newUser.username = defaultUser_default.username;
delete_existing_password_credential_if_any: {
const i = newUser.credentials.findIndex(credential => credential.type === "password");
if (i === -1) {
break delete_existing_password_credential_if_any;
}
newUser.credentials.splice(i, 1);
}
{
const credential = defaultUser_default.credentials.find(credential => credential.type === "password");
(0,assert/* assert */.h)(credential !== undefined);
newUser.credentials.push(credential);
}
{
const nameByClientId = Object.fromEntries(parsedRealmJson.clients.map(client => [client.id, client.clientId]));
const newClientRoles = {};
for (const clientRole of Object.values(parsedRealmJson.roles.client).flat()) {
const clientName = nameByClientId[clientRole.containerId];
(0,assert/* assert */.h)(clientName !== undefined);
((_b = newClientRoles[clientName]) !== null && _b !== void 0 ? _b : (newClientRoles[clientName] = [])).push(clientRole.name);
}
const { same: sameSet } = (0,same.sameFactory)({
takeIntoAccountArraysOrdering: false
});
for (const [clientName, roles] of Object.entries(newClientRoles)) {
keep_previous_ordering_if_possible: {
const roles_previous = (_c = newUser.clientRoles) === null || _c === void 0 ? void 0 : _c[clientName];
if (roles_previous === undefined) {
break keep_previous_ordering_if_possible;
}
if (!sameSet(roles_previous, roles)) {
break keep_previous_ordering_if_possible;
}
continue;
}
((_d = newUser.clientRoles) !== null && _d !== void 0 ? _d : (newUser.clientRoles = {}))[clientName] = roles;
}
}
if (defaultUser_preexisting === undefined) {
parsedRealmJson.users.push(newUser);
}
else {
const i = parsedRealmJson.users.indexOf(defaultUser_preexisting);
(0,assert/* assert */.h)(i !== -1);
parsedRealmJson.users[i] = newUser;
}
return { username: newUser.username };
}
function addOrEditClient(params) {
var _a;
const { parsedRealmJson, keycloakMajorVersionNumber } = params;
const parsedRealmJson_default = getDefaultConfig({ keycloakMajorVersionNumber });
const testClient_default = (() => {
const clients = parsedRealmJson_default.clients.filter(client => {
return JSON.stringify(client).includes(constants/* TEST_APP_URL */.jp);
});
(0,assert/* assert */.h)(clients.length === 1);
return clients[0];
})();
const clientIds_builtIn = parsedRealmJson_default.clients
.map(client => client.clientId)
.filter(clientId => clientId !== testClient_default.clientId);
const testClient_preexisting = (() => {
const clients = parsedRealmJson.clients
.filter(client => !clientIds_builtIn.includes(client.clientId))
.filter(client => client.protocol === "openid-connect");
{
const client = clients.find(client => client.clientId === testClient_default.clientId);
if (client !== undefined) {
return client;
}
}
{
const client = clients.find(client => {
var _a;
return ((_a = client.redirectUris) === null || _a === void 0 ? void 0 : _a.find(redirectUri => redirectUri.startsWith(constants/* TEST_APP_URL */.jp))) !== undefined;
});
if (client !== undefined) {
return client;
}
}
const [client] = clients;
if (client === undefined) {
return undefined;
}
return client;
})();
let testClient;
if (testClient_preexisting !== undefined) {
testClient = testClient_preexisting;
}
else {
testClient = structuredClone(testClient_default);
delete testClient.protocolMappers;
parsedRealmJson.clients.push(testClient);
}
testClient.redirectUris = [
`${constants/* TEST_APP_URL */.jp}/*`,
"http://localhost*",
"http://127.0.0.1*"
]
.sort()
.reverse();
((_a = testClient.attributes) !== null && _a !== void 0 ? _a : (testClient.attributes = {}))["post.logout.redirect.uris"] = "+";
testClient.webOrigins = ["*"];
return { clientId: testClient.clientId };
}
function editAccountConsoleAndSecurityAdminConsole(params) {
var _a, _b, _c, _d, _e;
const { parsedRealmJson } = params;
for (const clientId of ["account-console", "security-admin-console"]) {
const client = parsedRealmJson.clients.find(client => client.clientId === clientId);
(0,assert/* assert */.h)(client !== undefined);
{
const arr = ((_a = client.redirectUris) !== null && _a !== void 0 ? _a : (client.redirectUris = []));
for (const value of ["http://localhost*", "http://127.0.0.1*"]) {
if (!arr.includes(value)) {
arr.push(value);
}
}
(_b = client.redirectUris) === null || _b === void 0 ? void 0 : _b.sort().reverse();
}
((_c = client.attributes) !== null && _c !== void 0 ? _c : (client.attributes = {}))["post.logout.redirect.uris"] = "+";
client.webOrigins = ["*"];
admin_specific: {
if (clientId !== "security-admin-console") {
break admin_specific;
}
const protocolMapper_preexisting = (_d = client.protocolMappers) === null || _d === void 0 ? void 0 : _d.find(protocolMapper => {
if (protocolMapper.protocolMapper !== "oidc-hardcoded-claim-mapper") {
return false;
}
if (protocolMapper.protocol !== "openid-connect") {
return false;
}
if (protocolMapper.config === undefined) {
return false;
}
if (protocolMapper.config["claim.name"] !== "allowed-origins") {
return false;
}
return true;
});
let protocolMapper;
const config = {
"introspection.token.claim": "true",
"claim.value": '["*"]',
"userinfo.token.claim": "true",
"id.token.claim": "false",
"lightweight.claim": "true",
"access.token.claim": "true",
"claim.name": "allowed-origins",
"jsonType.label": "JSON",
"access.tokenResponse.claim": "false"
};
if (protocolMapper_preexisting !== undefined) {
protocolMapper = protocolMapper_preexisting;
}
else {
protocolMapper = {
id: "8fd0d584-7052-4d04-a615-d18a71050873",
name: "allowed-origins",
protocol: "openid-connect",
protocolMapper: "oidc-hardcoded-claim-mapper",
consentRequired: false,
config
};
((_e = client.protocolMappers) !== null && _e !== void 0 ? _e : (client.protocolMappers = [])).push(protocolMapper);
}
(0,assert/* assert */.h)(protocolMapper.config !== undefined);
if (config !== protocolMapper.config) {
Object.assign(protocolMapper.config, config);
}
}
}
}
//# sourceMappingURL=prepareRealmConfig.js.map
// EXTERNAL MODULE: ./dist/bin/tools/runPrettier.js
var runPrettier = __webpack_require__(48433);
;// CONCATENATED MODULE: ./dist/bin/tools/Stringifyable.js
const zStringifyableAtomic = (() => {
const zTargetType = lib.z.union([lib.z.string(), lib.z.number(), lib.z.boolean(), lib.z["null"]()]);
(0,assert/* assert */.h)();
return (0,id.id)(zTargetType);
})();
const zStringifyable = lib.z.any()
.superRefine((val, ctx) => {
const isStringifyable = (0,same.same)(JSON.parse(JSON.stringify(val)), val);
if (!isStringifyable) {
ctx.addIssue({
code: lib.z.ZodIssueCode.custom,
message: "Not stringifyable"
});
}
});
function getIsAtomic(stringifyable) {
return (["string", "number", "boolean"].includes(typeof stringifyable) ||
stringifyable === null);
}
const { getValueAtPath } = (() => {
function getValueAtPath_rec(stringifyable, path) {
if (path.length === 0) {
return stringifyable;
}
if (getIsAtomic(stringifyable)) {
return undefined;
}
const [first, ...rest] = path;
let dereferenced;
if (stringifyable instanceof Array) {
if (typeof first !== "number") {
return undefined;
}
dereferenced = stringifyable[first];
}
else {
if (typeof first !== "string") {
return undefined;
}
dereferenced = stringifyable[first];
}
if (dereferenced === undefined) {
return undefined;
}
return getValueAtPath_rec(dereferenced, rest);
}
function getValueAtPath(stringifyableObjectOrArray, path) {
return getValueAtPath_rec(stringifyableObjectOrArray, path);
}
return { getValueAtPath };
})();
//# sourceMappingURL=Stringifyable.js.map
;// CONCATENATED MODULE: ./dist/bin/tools/canonicalStringify.js
function canonicalStringify(params) {
const { data, referenceData } = params;
return JSON.stringify(makeDeterministicCopy({
path: [],
data,
getCanonicalKeys: path => {
const referenceValue = (() => {
const path_patched = [];
for (let i = 0; i < path.length; i++) {
let value_i = getValueAtPath(referenceData, [
...path_patched,
path[i]
]);
if (value_i !== undefined) {
path_patched.push(path[i]);
continue;
}
if (typeof path[i] !== "number") {
return undefined;
}
value_i = getValueAtPath(referenceData, [...path_patched, 0]);
if (value_i !== undefined) {
path_patched.push(0);
continue;
}
return undefined;
}
return getValueAtPath(referenceData, path_patched);
})();
if (referenceValue === undefined) {
return undefined;
}
if (getIsAtomic(referenceValue)) {
return undefined;
}
if (referenceValue instanceof Array) {
return undefined;
}
return Object.keys(referenceValue);
}
}), null, 2);
}
function makeDeterministicCopy(params) {
const { path, data, getCanonicalKeys } = params;
if (getIsAtomic(data)) {
return data;
}
if (data instanceof Array) {
return makeDeterministicCopy_array({
path,
data,
getCanonicalKeys
});
}
return makeDeterministicCopy_record({
path,
data,
getCanonicalKeys
});
}
function makeDeterministicCopy_record(params) {
const { path, data, getCanonicalKeys } = params;
const keysOfAtomicValues = [];
const keysOfNonAtomicValues = [];
for (const [key, value] of Object.entries(data)) {
if (getIsAtomic(value)) {
keysOfAtomicValues.push(key);
}
else {
keysOfNonAtomicValues.push(key);
}
}
keysOfAtomicValues.sort();
keysOfNonAtomicValues.sort();
const keys = [...keysOfAtomicValues, ...keysOfNonAtomicValues];
reorder_according_to_canonical: {
const canonicalKeys = getCanonicalKeys(path);
if (canonicalKeys === undefined) {
break reorder_according_to_canonical;
}
const keys_toPrepend = [];
for (const key of canonicalKeys) {
const indexOfKey = keys.indexOf(key);
if (indexOfKey === -1) {
continue;
}
keys.splice(indexOfKey, 1);
keys_toPrepend.push(key);
}
keys.unshift(...keys_toPrepend);
}
const result = {};
for (const key of keys) {
result[key] = makeDeterministicCopy({
path: [...path, key],
data: data[key],
getCanonicalKeys
});
}
return result;
}
function makeDeterministicCopy_array(params) {
const { path, data, getCanonicalKeys } = params;
return [...data].map((entry, i) => makeDeterministicCopy({
path: [...path, i],
data: entry,
getCanonicalKeys
}));
}
//# sourceMappingURL=canonicalStringify.js.map
;// CONCATENATED MODULE: ./dist/bin/start-keycloak/realmConfig/ParsedRealmJson/writeRealmJsonFile.js
async function writeRealmJsonFile(params) {
const { realmJsonFilePath, parsedRealmJson, keycloakMajorVersionNumber } = params;
let sourceCode = canonicalStringify({
data: parsedRealmJson,
referenceData: getDefaultConfig({
keycloakMajorVersionNumber
})
});
if (await (0,runPrettier/* getIsPrettierAvailable */.MT)()) {
sourceCode = await (0,runPrettier/* runPrettier */.eY)({
sourceCode: sourceCode,
filePath: realmJsonFilePath
});
}
await promises_.writeFile(realmJsonFilePath, Buffer.from(sourceCode, "utf8"));
}
//# sourceMappingURL=writeRealmJsonFile.js.map
;// CONCATENATED MODULE: ./dist/bin/start-keycloak/realmConfig/ParsedRealmJson/index.js
//# sourceMappingURL=index.js.map
;// CONCATENATE