@keycloakify/angular 0.0.1-rc.9 → 0.0.1

package/src/bin/initialize-account-theme/initialize-account-theme.ts

@@ -0,0 +1,98 @@
+import type { BuildContext } from '../core';
+import child_process from 'child_process';
+import chalk from 'chalk';
+import { join as pathJoin, relative as pathRelative } from 'path';
+import * as fs from 'fs';
+import { updateAccountThemeImplementationInConfig } from './updateAccountThemeImplementationInConfig';
+import { command as updateKcGenCommand } from '../update-kc-gen';
+import { getThisCodebaseRootDirPath } from '../tools/getThisCodebaseRootDirPath';
+
+export async function command(params: { buildContext: BuildContext }) {
+    const { buildContext } = params;
+
+    const accountThemeSrcDirPath = pathJoin(buildContext.themeSrcDirPath, 'account');
+
+    if (
+        fs.existsSync(accountThemeSrcDirPath) &&
+        fs.readdirSync(accountThemeSrcDirPath).length > 0
+    ) {
+        console.warn(
+            chalk.red(
+                `There is already a ${pathRelative(
+                    process.cwd(),
+                    accountThemeSrcDirPath
+                )} directory in your project. Aborting.`
+            )
+        );
+
+        process.exit(-1);
+    }
+
+    exit_if_uncommitted_changes: {
+        let hasUncommittedChanges: boolean | undefined = undefined;
+
+        try {
+            hasUncommittedChanges =
+                child_process
+                    .execSync(`git status --porcelain`, {
+                        cwd: buildContext.projectDirPath
+                    })
+                    .toString()
+                    .trim() !== '';
+        } catch {
+            // Probably not a git repository
+            break exit_if_uncommitted_changes;
+        }
+
+        if (!hasUncommittedChanges) {
+            break exit_if_uncommitted_changes;
+        }
+        console.warn(
+            [
+                chalk.red(
+                    'Please commit or stash your changes before running this command.\n'
+                ),
+                "This command will modify your project's files so it's better to have a clean working directory",
+                'so that you can easily see what has been changed and revert if needed.'
+            ].join(' ')
+        );
+
+        process.exit(-1);
+    }
+
+    const accountThemeType = 'Multi-Page';
+
+    fs.cpSync(
+        pathJoin(
+            getThisCodebaseRootDirPath(),
+            'src',
+            'bin',
+            'initialize-account-theme',
+            'boilerplate'
+        ),
+        accountThemeSrcDirPath,
+        { recursive: true }
+    );
+
+    updateAccountThemeImplementationInConfig({ buildContext, accountThemeType });
+
+    updateKcGenCommand({
+        buildContext: {
+            ...buildContext,
+            implementedThemeTypes: {
+                ...buildContext.implementedThemeTypes,
+                account: {
+                    isImplemented: true,
+                    type: accountThemeType
+                }
+            }
+        }
+    });
+
+    console.log(
+        [
+            chalk.green(`The ${accountThemeType} account theme has been initialized.`),
+            `Directory created: ${chalk.bold(pathRelative(process.cwd(), accountThemeSrcDirPath))}`
+        ].join('\n')
+    );
+}

package/src/bin/initialize-account-theme/updateAccountThemeImplementationInConfig.ts

@@ -0,0 +1,101 @@
+import { join as pathJoin } from 'path';
+import { assert, type Equals } from 'tsafe/assert';
+import type { BuildContext } from '../core';
+import * as fs from 'fs';
+import chalk from 'chalk';
+import { z } from 'zod';
+import { id } from 'tsafe/id';
+import { is } from 'tsafe/is';
+
+export type BuildContextLike = {
+    bundler: BuildContext['bundler'];
+    projectDirPath: string;
+    packageJsonFilePath: string;
+};
+
+assert<BuildContext extends BuildContextLike ? true : false>();
+
+export function updateAccountThemeImplementationInConfig(params: {
+    buildContext: BuildContext;
+    accountThemeType: 'Multi-Page';
+}) {
+    const { buildContext, accountThemeType } = params;
+
+    switch (buildContext.bundler) {
+        case 'vite':
+            {
+                const viteConfigPath = pathJoin(
+                    buildContext.projectDirPath,
+                    'vite.config.ts'
+                );
+
+                if (!fs.existsSync(viteConfigPath)) {
+                    console.log(
+                        chalk.bold(
+                            `You must manually set the accountThemeImplementation to "${accountThemeType}" in your vite config`
+                        )
+                    );
+                    break;
+                }
+
+                const viteConfigContent = fs
+                    .readFileSync(viteConfigPath)
+                    .toString('utf8');
+
+                const modifiedViteConfigContent = viteConfigContent.replace(
+                    /["']?accountThemeImplementation["']?\s*:\s*["']none["']/,
+                    `accountThemeImplementation: '${accountThemeType}'`
+                );
+
+                if (modifiedViteConfigContent === viteConfigContent) {
+                    console.log(
+                        chalk.yellow(
+                            `You must manually set the accountThemeImplementation to "${accountThemeType}" in your vite.config.ts`
+                        )
+                    );
+                    break;
+                }
+
+                fs.writeFileSync(viteConfigPath, modifiedViteConfigContent);
+            }
+            break;
+        case 'webpack':
+            {
+                const parsedPackageJson = (() => {
+                    type ParsedPackageJson = {
+                        keycloakify: Record<string, unknown>;
+                    };
+
+                    const zParsedPackageJson = (() => {
+                        type TargetType = ParsedPackageJson;
+
+                        const zTargetType = z.object({
+                            keycloakify: z.record(z.unknown())
+                        });
+
+                        assert<Equals<z.infer<typeof zTargetType>, TargetType>>();
+
+                        return id<z.ZodType<TargetType>>(zTargetType);
+                    })();
+
+                    const parsedPackageJson = JSON.parse(
+                        fs.readFileSync(buildContext.packageJsonFilePath).toString('utf8')
+                    );
+
+                    zParsedPackageJson.parse(parsedPackageJson);
+                    assert(is<ParsedPackageJson>(parsedPackageJson));
+
+                    return parsedPackageJson;
+                })();
+
+                parsedPackageJson.keycloakify.accountThemeImplementation =
+                    accountThemeType;
+
+                fs.writeFileSync(
+                    buildContext.packageJsonFilePath,
+                    Buffer.from(JSON.stringify(parsedPackageJson, undefined, 4), 'utf8')
+                );
+            }
+            break;
+    }
+}

package/src/bin/main.ts

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+
+import { readParams, NOT_IMPLEMENTED_EXIT_CODE } from './core';
+
+const { buildContext, commandName } = readParams({ apiVersion: 'v1' });
+
+(async () => {
+    switch (commandName) {
+        case 'add-story':
+            {
+                console.log(
+                    "Not yet supported by @keycloakify/angular, we're working on it!"
+                );
+                process.exit(-1);
+            }
+            return;
+        case 'eject-page':
+            {
+                const { command } = await import('./eject-page');
+                command({ buildContext });
+            }
+            return;
+        case 'update-kc-gen':
+            {
+                const { command } = await import('./update-kc-gen');
+                command({ buildContext });
+            }
+            return;
+        case 'initialize-account-theme':
+            {
+                const { command } = await import('./initialize-account-theme');
+                command({ buildContext });
+            }
+            return;
+        default:
+            process.exit(NOT_IMPLEMENTED_EXIT_CODE);
+    }
+})();

package/src/bin/tools/SemVer.ts

@@ -0,0 +1,114 @@
+export type SemVer = {
+    major: number;
+    minor: number;
+    patch: number;
+    rc?: number;
+    parsedFrom: string;
+};
+
+export namespace SemVer {
+    const bumpTypes = ['major', 'minor', 'patch', 'rc', 'no bump'] as const;
+
+    export type BumpType = (typeof bumpTypes)[number];
+
+    export function parse(versionStr: string): SemVer {
+        const match = versionStr.match(
+            /^v?([0-9]+)\.([0-9]+)(?:\.([0-9]+))?(?:-rc.([0-9]+))?$/
+        );
+
+        if (!match) {
+            throw new Error(`${versionStr} is not a valid semantic version`);
+        }
+
+        const semVer: Omit<SemVer, 'parsedFrom'> = {
+            major: parseInt(match[1]),
+            minor: parseInt(match[2]),
+            patch: (() => {
+                const str = match[3];
+
+                return str === undefined ? 0 : parseInt(str);
+            })(),
+            ...(() => {
+                const str = match[4];
+                return str === undefined ? {} : { rc: parseInt(str) };
+            })()
+        };
+
+        const initialStr = stringify(semVer);
+
+        Object.defineProperty(semVer, 'parsedFrom', {
+            enumerable: true,
+            get: function () {
+                const currentStr = stringify(this);
+
+                if (currentStr !== initialStr) {
+                    throw new Error(
+                        `SemVer.parsedFrom can't be read anymore, the version have been modified from ${initialStr} to ${currentStr}`
+                    );
+                }
+
+                return versionStr;
+            }
+        });
+
+        return semVer as any;
+    }
+
+    export function stringify(v: Omit<SemVer, 'parsedFrom'>): string {
+        return `${v.major}.${v.minor}.${v.patch}${v.rc === undefined ? '' : `-rc.${v.rc}`}`;
+    }
+
+    /**
+     *
+     * v1  <  v2  => -1
+     * v1 === v2  => 0
+     * v1  >  v2  => 1
+     *
+     */
+    export function compare(v1: SemVer, v2: SemVer): -1 | 0 | 1 {
+        const sign = (diff: number): -1 | 0 | 1 => (diff === 0 ? 0 : diff < 0 ? -1 : 1);
+        const noUndefined = (n: number | undefined) => n ?? Infinity;
+
+        for (const level of ['major', 'minor', 'patch', 'rc'] as const) {
+            if (noUndefined(v1[level]) !== noUndefined(v2[level])) {
+                return sign(noUndefined(v1[level]) - noUndefined(v2[level]));
+            }
+        }
+
+        return 0;
+    }
+
+    /*
+    console.log(compare(parse("3.0.0-rc.3"), parse("3.0.0")) === -1 )
+    console.log(compare(parse("3.0.0-rc.3"), parse("3.0.0-rc.4")) === -1 )
+    console.log(compare(parse("3.0.0-rc.3"), parse("4.0.0")) === -1 )
+    */
+
+    export function bumpType(params: {
+        versionBehind: string | SemVer;
+        versionAhead: string | SemVer;
+    }): BumpType | 'no bump' {
+        const versionAhead =
+            typeof params.versionAhead === 'string'
+                ? parse(params.versionAhead)
+                : params.versionAhead;
+        const versionBehind =
+            typeof params.versionBehind === 'string'
+                ? parse(params.versionBehind)
+                : params.versionBehind;
+
+        if (compare(versionBehind, versionAhead) === 1) {
+            throw new Error(
+                `Version regression ${stringify(versionBehind)} -> ${stringify(versionAhead)}`
+            );
+        }
+
+        for (const level of ['major', 'minor', 'patch', 'rc'] as const) {
+            if (versionBehind[level] !== versionAhead[level]) {
+                return level;
+            }
+        }
+
+        return 'no bump';
+    }
+}

package/src/bin/tools/String.prototype.replaceAll.ts

@@ -0,0 +1,37 @@
+export function replaceAll(
+    string: string,
+    searchValue: string | RegExp,
+    replaceValue: string
+): string {
+    if ((string as any).replaceAll !== undefined) {
+        return (string as any).replaceAll(searchValue, replaceValue);
+    }
+
+    // If the searchValue is a string
+    if (typeof searchValue === 'string') {
+        // Escape special characters in the string to be used in a regex
+        var escapedSearchValue = searchValue.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        var regex = new RegExp(escapedSearchValue, 'g');
+
+        return string.replace(regex, replaceValue);
+    }
+
+    // If the searchValue is a global RegExp, use it directly
+    if (searchValue instanceof RegExp && searchValue.global) {
+        return string.replace(searchValue, replaceValue);
+    }
+
+    // If the searchValue is a non-global RegExp, throw an error
+    if (searchValue instanceof RegExp) {
+        throw new TypeError('replaceAll must be called with a global RegExp');
+    }
+
+    // Convert searchValue to string if it's not a string or RegExp
+    var searchString = String(searchValue);
+    var regexFromString = new RegExp(
+        searchString.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'),
+        'g'
+    );
+
+    return string.replace(regexFromString, replaceValue);
+}

package/src/bin/tools/crawl.ts

@@ -0,0 +1,35 @@
+import * as fs from 'fs';
+import { join as pathJoin, relative as pathRelative } from 'path';
+
+const crawlRec = (dirPath: string, filePaths: string[]) => {
+    for (const basename of fs.readdirSync(dirPath)) {
+        const fileOrDirPath = pathJoin(dirPath, basename);
+
+        if (fs.lstatSync(fileOrDirPath).isDirectory()) {
+            crawlRec(fileOrDirPath, filePaths);
+
+            continue;
+        }
+
+        filePaths.push(fileOrDirPath);
+    }
+};
+
+/** List all files in a given directory return paths relative to the dir_path */
+export function crawl(params: {
+    dirPath: string;
+    returnedPathsType: 'absolute' | 'relative to dirPath';
+}): string[] {
+    const { dirPath, returnedPathsType } = params;
+
+    const filePaths: string[] = [];
+
+    crawlRec(dirPath, filePaths);
+
+    switch (returnedPathsType) {
+        case 'absolute':
+            return filePaths;
+        case 'relative to dirPath':
+            return filePaths.map(filePath => pathRelative(dirPath, filePath));
+    }
+}

package/src/bin/tools/fs.rmSync.ts

@@ -0,0 +1,34 @@
+import * as fs from 'fs';
+import { join as pathJoin } from 'path';
+import { SemVer } from './SemVer';
+
+/**
+ * Polyfill of fs.rmSync(dirPath, { "recursive": true })
+ * For older version of Node
+ */
+export function rmSync(dirPath: string, options: { recursive: true; force?: true }) {
+    if (SemVer.compare(SemVer.parse(process.version), SemVer.parse('14.14.0')) > 0) {
+        fs.rmSync(dirPath, options);
+        return;
+    }
+
+    const { force = true } = options;
+
+    if (force && !fs.existsSync(dirPath)) {
+        return;
+    }
+
+    const removeDir_rec = (dirPath: string) =>
+        fs.readdirSync(dirPath).forEach(basename => {
+            const fileOrDirPath = pathJoin(dirPath, basename);
+
+            if (fs.lstatSync(fileOrDirPath).isDirectory()) {
+                removeDir_rec(fileOrDirPath);
+                return;
+            } else {
+                fs.unlinkSync(fileOrDirPath);
+            }
+        });
+
+    removeDir_rec(dirPath);
+}

package/src/bin/tools/getThisCodebaseRootDirPath.ts

@@ -0,0 +1,19 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+function getThisCodebaseRootDirPath_rec(dirPath: string): string {
+    if (fs.existsSync(path.join(dirPath, 'package.json'))) {
+        return dirPath;
+    }
+    return getThisCodebaseRootDirPath_rec(path.join(dirPath, '..'));
+}
+
+let result: string | undefined = undefined;
+
+export function getThisCodebaseRootDirPath(): string {
+    if (result !== undefined) {
+        return result;
+    }
+
+    return (result = getThisCodebaseRootDirPath_rec(__dirname));
+}

package/src/bin/tools/kebabCaseToSnakeCase.ts

@@ -0,0 +1,7 @@
+import { capitalize } from 'tsafe/capitalize';
+
+export function kebabCaseToCamelCase(kebabCaseString: string): string {
+    const [first, ...rest] = kebabCaseString.split('-');
+
+    return [first, ...rest.map(capitalize)].join('');
+}

package/src/bin/tools/transformCodebase.ts

@@ -0,0 +1,88 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { crawl } from './crawl';
+import { rmSync } from '../tools/fs.rmSync';
+
+type TransformSourceCode = (params: {
+    sourceCode: Buffer;
+    filePath: string;
+    fileRelativePath: string;
+}) =>
+    | {
+          modifiedSourceCode: Buffer;
+          newFileName?: string;
+      }
+    | undefined;
+
+/**
+ * Apply a transformation function to every file of directory
+ * If source and destination are the same this function can be used to apply the transformation in place
+ * like filtering out some files or modifying them.
+ * */
+export function transformCodebase(params: {
+    srcDirPath: string;
+    destDirPath: string;
+    transformSourceCode?: TransformSourceCode;
+}) {
+    const { srcDirPath, transformSourceCode } = params;
+
+    const isTargetSameAsSource = path.relative(srcDirPath, params.destDirPath) === '';
+
+    const destDirPath = isTargetSameAsSource
+        ? path.join(srcDirPath, '..', 'tmp_xOsPdkPsTdzPs34sOkHs')
+        : params.destDirPath;
+
+    fs.mkdirSync(destDirPath, {
+        recursive: true
+    });
+
+    for (const fileRelativePath of crawl({
+        dirPath: srcDirPath,
+        returnedPathsType: 'relative to dirPath'
+    })) {
+        const filePath = path.join(srcDirPath, fileRelativePath);
+        const destFilePath = path.join(destDirPath, fileRelativePath);
+
+        // NOTE: Optimization, if we don't need to transform the file, just copy
+        // it using the lower level implementation.
+        if (transformSourceCode === undefined) {
+            fs.mkdirSync(path.dirname(destFilePath), {
+                recursive: true
+            });
+
+            fs.copyFileSync(filePath, destFilePath);
+
+            continue;
+        }
+
+        const transformSourceCodeResult = transformSourceCode({
+            sourceCode: fs.readFileSync(filePath),
+            filePath,
+            fileRelativePath
+        });
+
+        if (transformSourceCodeResult === undefined) {
+            continue;
+        }
+
+        fs.mkdirSync(path.dirname(destFilePath), {
+            recursive: true
+        });
+
+        const { newFileName, modifiedSourceCode } = transformSourceCodeResult;
+
+        fs.writeFileSync(
+            path.join(
+                path.dirname(destFilePath),
+                newFileName ?? path.basename(destFilePath)
+            ),
+            modifiedSourceCode
+        );
+    }
+
+    if (isTargetSameAsSource) {
+        rmSync(srcDirPath, { recursive: true });
+
+        fs.renameSync(destDirPath, srcDirPath);
+    }
+}

package/src/bin/tsconfig.json

@@ -0,0 +1,20 @@
+{
+    "compilerOptions": {
+        "sourceMap": false,
+        "newLine": "LF",
+        "noUnusedLocals": true,
+        "noUnusedParameters": true,
+        "strict": true,
+        "downlevelIteration": true,
+        "noFallthroughCasesInSwitch": true,
+        "composite": true,
+        "rootDir": ".",
+        "module": "ES2020",
+        "target": "ES2017",
+        "esModuleInterop": true,
+        "lib": ["es2015", "ES2019.Object"],
+        "moduleResolution": "node"
+    },
+    "include": ["**/*.ts"],
+    "exclude": ["initialize-account-theme/boilerplate"]
+}