@skmtc/core 0.0.222 → 0.0.223

package/esm/oas/unknown/unknown-types.js

@@ -1,8 +0,0 @@
-import { z } from 'zod';
-export const oasUnknownData = z.object({
-    oasType: z.literal('schema'),
-    title: z.string().optional(),
-    description: z.string().optional(),
-    default: z.unknown().optional(),
-    type: z.literal('unknown')
-});

package/esm/oas/void/Void.js

@@ -1,49 +0,0 @@
-import { OasBase } from '../../oas-elements/OasBase.js';
-import { Trail } from '../../context/Trail.js';
-export class OasVoid extends OasBase {
-    constructor({ fields, trail, skipped, context }) {
-        super({ trail, skipped, context });
-        Object.defineProperty(this, "oasType", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 'schema'
-        });
-        Object.defineProperty(this, "type", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 'void'
-        });
-        Object.defineProperty(this, "fields", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.fields = fields;
-    }
-    static empty(context) {
-        return new OasVoid({
-            fields: {},
-            trail: new Trail(),
-            context,
-            skipped: {}
-        });
-    }
-    get title() {
-        return this.fields.title;
-    }
-    get description() {
-        return this.fields.description;
-    }
-    isRef() {
-        return false;
-    }
-    resolve() {
-        return this;
-    }
-    resolveOnce() {
-        return this;
-    }
-}

package/esm/oas-elements/OasBase.js

@@ -1,27 +0,0 @@
-export class OasBase {
-    constructor({ trail, context, skipped }) {
-        Object.defineProperty(this, "trail", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "context", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.trail = trail;
-        this.context = context;
-        this.logSkippedFields(skipped);
-    }
-    logSkippedFields(skipped) {
-        Object.entries(skipped).forEach(([key, value]) => {
-            console.warn(JSON.stringify({
-                trail: this.trail.add(key).toString(),
-                message: `Property not yet implemented. Please request from support if needed - ${JSON.stringify(value).slice(0, 20)}`
-            }));
-        });
-    }
-}

package/esm/package.json

@@ -1,3 +0,0 @@
-{
-  "type": "module"
-}

package/esm/parse/parse.js

@@ -1,16 +0,0 @@
-import { toDocumentV3 } from '../oas/document/toDocumentV3.js';
-import { Trail } from '../context/Trail.js';
-export const oasToSkmtc = (context) => {
-    const { parsedDocument } = context;
-    const trail = new Trail({
-        document: parsedDocument
-    });
-    if (!parsedDocument.openapi.startsWith('3.0.')) {
-        throw new Error('Only OpenAPI v3 is supported');
-    }
-    return toDocumentV3({
-        document: parsedDocument,
-        trail,
-        context
-    });
-};

package/esm/schemas/client.js

@@ -1,174 +0,0 @@
-import "../_dnt.polyfills.js";
-export default {
-    "$schema": "https://json-schema.org/draft-07/schema",
-    "$id": "https://schemas.skmtc.dev/client.json",
-    "title": "Settings",
-    "description": "Settings for Skmtc code generation",
-    "type": "object",
-    "properties": {
-        "serverName": {
-            "type": "string"
-        },
-        "stackName": {
-            "type": "string"
-        },
-        "deploymentId": {
-            "type": "string"
-        },
-        "settings": {
-            "$ref": "#/definitions/ClientSettings"
-        }
-    },
-    "required": ["settings"],
-    "definitions": {
-        "ClientSettings": {
-            "properties": {
-                "alias": {
-                    "type": "object",
-                    "additionalProperties": {
-                        "type": "string"
-                    }
-                },
-                "basePath": {
-                    "type": "string"
-                },
-                "generators": {
-                    "$ref": "#/definitions/Generators"
-                }
-            },
-            "required": ["generators"]
-        },
-        "Generators": {
-            "oneOf": [{
-                    "$ref": "#/definitions/Transformers"
-                }, {
-                    "$ref": "#/definitions/Models"
-                }]
-        },
-        "Schemas": {
-            "type": "object",
-            "properties": {
-                "root": {
-                    "$ref": "#/definitions/Root"
-                },
-                "schemas": {
-                    "type": "object",
-                    "additionalProperties": {
-                        "$ref": "#/definitions/Model"
-                    }
-                }
-            }
-        },
-        "Root": {
-            "type": "object",
-            "required": ["creatorSource"],
-            "properties": {
-                "defaultSelected": {
-                    "type": "boolean"
-                },
-                "creatorSource": {
-                    "type": "string"
-                }
-            },
-            "additionalProperties": {
-                "type": "string"
-            }
-        },
-        "Transformers": {
-            "type": "object",
-            "additionalProperties": {
-                "type": "object",
-                "properties": {
-                    "root": {
-                        "$ref": "#/definitions/Root"
-                    },
-                    "operations": {
-                        "$ref": "#/definitions/Operations"
-                    }
-                }
-            }
-        },
-        "Models": {
-            "type": "object",
-            "additionalProperties": {
-                "type": "object",
-                "properties": {
-                    "root": {
-                        "$ref": "#/definitions/Root"
-                    },
-                    "models": {
-                        "$ref": "#/definitions/Schemas"
-                    }
-                }
-            }
-        },
-        "Operation": {
-            "type": "object",
-            "required": ["selected"],
-            "properties": {
-                "selected": {
-                    "type": "boolean"
-                },
-                "name": {
-                    "type": "string"
-                },
-                "importFrom": {
-                    "type": "string"
-                },
-                "exportPath": {
-                    "type": "string"
-                }
-            }
-        },
-        "Model": {
-            "type": "object",
-            "required": ["selected"],
-            "properties": {
-                "selected": {
-                    "type": "boolean"
-                },
-                "name": {
-                    "type": "string"
-                },
-                "importFrom": {
-                    "type": "string"
-                },
-                "exportPath": {
-                    "type": "string"
-                }
-            }
-        },
-        "Operations": {
-            "type": "object",
-            "additionalProperties": {
-                "type": "object",
-                "properties": {
-                    "get": {
-                        "$ref": "#/definitions/Operation"
-                    },
-                    "post": {
-                        "$ref": "#/definitions/Operation"
-                    },
-                    "put": {
-                        "$ref": "#/definitions/Operation"
-                    },
-                    "delete": {
-                        "$ref": "#/definitions/Operation"
-                    },
-                    "patch": {
-                        "$ref": "#/definitions/Operation"
-                    },
-                    "options": {
-                        "$ref": "#/definitions/Operation"
-                    },
-                    "head": {
-                        "$ref": "#/definitions/Operation"
-                    },
-                    "trace": {
-                        "$ref": "#/definitions/Operation"
-                    }
-                }
-            }
-        }
-    }
-};

package/esm/server/createServer.js

@@ -1,107 +0,0 @@
-import * as Sentry from '@sentry/deno';
-import { Hono } from 'hono';
-import { match } from 'ts-pattern';
-import { z } from 'zod';
-import { clientSettings as settingsSchema } from '../types/Settings.js';
-import { generate, parseSchema } from '../generate/generate.js';
-import { ParseContext } from '../context/ParseContext.js';
-import { CoreContext } from '../context/CoreContext.js';
-import { oasToSkmtc } from '../parse/parse.js';
-const postSettingsBody = z.object({
-    schema: z.string(),
-    clientSettings: settingsSchema.optional()
-});
-const postGenerateBody = z.object({
-    schema: z.string(),
-    clientSettings: settingsSchema.optional(),
-    prettier: z.record(z.unknown()).optional()
-});
-export const createServer = (generators) => {
-    const app = new Hono();
-    app.post('/artifacts', async (c) => {
-        const result = await Sentry.startSpan({ name: 'POST /artifacts' }, async () => {
-            console.log('HEADERS ', c.req.header());
-            const body = await Sentry.startSpan({ name: 'Parse JSON' }, () => c.req.json());
-            const { schema, clientSettings, prettier } = await Sentry.startSpan({ name: 'Validate request content' }, () => postGenerateBody.parseAsync(body));
-            return await Sentry.startSpan({ name: 'Generate' }, async () => {
-                const generatorsMap = Object.fromEntries(generators.map(generator => [generator.id, generator]));
-                return await generate({
-                    schema,
-                    prettier,
-                    settings: clientSettings,
-                    generatorsMap
-                });
-            });
-        });
-        return c.json(result);
-    });
-    app.get('/generators', c => {
-        return Sentry.startSpan({ name: 'GET /generators' }, () => c.json({ generators }));
-    });
-    app.post('/settings', async (c) => {
-        return await Sentry.startSpan({ name: 'POST /settings' }, async () => {
-            const body = await c.req.json();
-            const { clientSettings } = postSettingsBody.parse(body);
-            const oasDocument = await toOasDocument(body.schema);
-            const out = generators.map(generator => {
-                const generatorSettings = clientSettings?.generators?.find(({ id }) => id === generator.id);
-                const generatorType = generator.type;
-                return match(generatorType)
-                    .with('operation', () => ({
-                    ...generatorSettings,
-                    id: generator.id,
-                    operations: toOperations({
-                        generator: generator,
-                        oasDocument,
-                        operationsSettings: generatorSettings && 'operations' in generatorSettings
-                            ? generatorSettings.operations
-                            : undefined
-                    })
-                }))
-                    .with('model', () => ({
-                    ...generatorSettings,
-                    id: generator.id,
-                    models: toModels({
-                        oasDocument,
-                        modelsSettings: generatorSettings && 'models' in generatorSettings
-                            ? generatorSettings.models
-                            : undefined
-                    })
-                }))
-                    .otherwise(matched => {
-                    throw new Error(`Invalid generator type: '${matched}' for ${generator.id}`);
-                });
-            });
-            return c.json({ generators: out });
-        });
-    });
-    return app;
-};
-const toModels = ({ oasDocument, modelsSettings }) => {
-    return Object.fromEntries(Object.keys(oasDocument.components?.schemas ?? {}).map(refName => [
-        refName,
-        modelsSettings?.[refName]
-            ? modelsSettings?.[refName]
-            : { selected: false }
-    ]));
-};
-const toOperations = ({ generator, oasDocument, operationsSettings }) => {
-    return Object.values(oasDocument.operations)
-        .filter(operation => generator.isSupported?.(operation) ?? true)
-        .reduce((acc, operation) => {
-        const { path, method } = operation;
-        acc[path] = acc[path] ?? {};
-        acc[path][method] = operationsSettings?.[path]?.[method]
-            ? operationsSettings?.[path]?.[method]
-            : { selected: false };
-        return acc;
-    }, {});
-};
-const toOasDocument = (schema) => {
-    const parsedDocument = parseSchema(schema);
-    const parseContext = new ParseContext({ parsedDocument });
-    const context = new CoreContext({
-        phase: { type: 'parse', context: parseContext }
-    });
-    return oasToSkmtc(context);
-};

package/esm/types/Brand.js

@@ -1 +0,0 @@
-export {};

package/esm/types/CustomValue.js

@@ -1,28 +0,0 @@
-import { ValueBase } from '../dsl/ValueBase.js';
-export class CustomValue extends ValueBase {
-    constructor({ context, value, generatorKey }) {
-        super({ context, generatorKey });
-        Object.defineProperty(this, "type", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 'custom'
-        });
-        Object.defineProperty(this, "value", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.value = value;
-    }
-    toString() {
-        return `${this.value}`;
-    }
-}
-export const isCustomValue = (value) => {
-    return Boolean(value &&
-        typeof value === 'object' &&
-        'type' in value &&
-        value.type === 'custom');
-};

package/esm/types/GeneratedValue.js

@@ -1 +0,0 @@
-export {};

package/esm/types/GenerationType.js

@@ -1,15 +0,0 @@
-/**
- * 'force' - will generate content even it is not selected.
- * Use this option when generating code via a dependency.
- * For example, when you are generating a form and it needs
- * an accompanying API client as well. You should use 'force'
- * when generating the API client to ensure it is generated
- * event the API client itself is not selected.
- *
- * 'regular' - will generate content only if it is selected.
- *
- * 'lazy' - will create a Driver instance but not apply it, until
- * the value is accessed. This is useful when you want a quick way
- * to access settings for a creator without generating the content.
- */
-export {};

package/esm/types/GeneratorKeys.js

@@ -1,13 +0,0 @@
-export const toOperationGeneratorKey = ({ generatorId, ...rest }) => {
-    const { path, method } = 'operation' in rest ? rest.operation : rest;
-    const nakedKey = `${generatorId}|${path}|${method}`;
-    return nakedKey;
-};
-export const toModelGeneratorKey = ({ generatorId, refName }) => {
-    const nakedKey = `${generatorId}|${refName}`;
-    return nakedKey;
-};
-export const toGeneratorOnlyKey = ({ generatorId }) => {
-    const nakedKey = `${generatorId}`;
-    return nakedKey;
-};

package/esm/types/Method.js

@@ -1,31 +0,0 @@
-import { z } from 'zod';
-export const methodValues = [
-    'get',
-    'put',
-    'post',
-    'delete',
-    'options',
-    'head',
-    'patch',
-    'trace'
-];
-export const methodValuesNoTrace = [
-    'get',
-    'put',
-    'post',
-    'delete',
-    'options',
-    'head',
-    'patch'
-];
-export const method = z.enum([
-    'get',
-    'put',
-    'post',
-    'delete',
-    'options',
-    'head',
-    'patch',
-    'trace'
-]);
-export const methods = z.array(method);

package/esm/types/Modifiers.js

@@ -1 +0,0 @@
-export {};

package/esm/types/RefName.js

@@ -1 +0,0 @@
-export {};

package/esm/types/Settings.js

@@ -1,42 +0,0 @@
-import "../_dnt.polyfills.js";
-import { method } from './Method.js';
-import { z } from 'zod';
-export const baseSettings = z.object({
-    selected: z.boolean(),
-    name: z.string().optional(),
-    importFrom: z.string().optional(),
-    exportPath: z.string().optional()
-});
-export const operationsGeneratorSettings = z.object({
-    id: z.string(),
-    exportPath: z.string().optional(),
-    description: z.string().optional(),
-    operations: z.record(z.record(method, baseSettings))
-});
-export const modelsGeneratorSettings = z.object({
-    id: z.string(),
-    exportPath: z.string().optional(),
-    description: z.string().optional(),
-    models: z.record(baseSettings)
-});
-export const clientGeneratorSettings = z.union([
-    operationsGeneratorSettings,
-    modelsGeneratorSettings
-]);
-export const clientSettings = z.object({
-    basePath: z.string().optional(),
-    alias: z.record(z.string()).optional(),
-    generators: z.array(clientGeneratorSettings)
-});
-export const skmtcClientConfig = z.object({
-    serverName: z.string().optional(),
-    stackName: z.string().optional(),
-    deploymentId: z.string().optional(),
-    settings: clientSettings
-});
-export const generatorType = z.enum(['operation', 'model']);
-export const skmtcServerConfig = z.object({
-    name: z.string().optional(),
-    version: z.string().optional(),
-    generators: z.array(z.string())
-});

package/esm/types/TypeSystem.js

@@ -1 +0,0 @@
-export {};

package/esm/types/prettierConfig.js

@@ -1,46 +0,0 @@
-import { z } from 'zod';
-export const prettierConfigType = z.object({
-    printWidth: z.number().optional(),
-    tabWidth: z.number().optional(),
-    useTabs: z.boolean().optional(),
-    semi: z.boolean().optional(),
-    singleQuote: z.boolean().optional(),
-    quoteProps: z
-        .union([
-        z.literal('as-needed'),
-        z.literal('consistent'),
-        z.literal('preserve')
-    ])
-        .optional(),
-    jsxSingleQuote: z.boolean().optional(),
-    trailingComma: z
-        .union([z.literal('none'), z.literal('es5'), z.literal('all')])
-        .optional(),
-    bracketSameLine: z.boolean().optional(),
-    bracketSpacing: z.boolean().optional(),
-    jsxBracketSameLine: z.boolean().optional(),
-    arrowParens: z.union([z.literal('avoid'), z.literal('always')]).optional(),
-    rangeStart: z.number().optional(),
-    rangeEnd: z.number().optional(),
-    requirePragma: z.boolean().optional(),
-    insertPragma: z.boolean().optional(),
-    proseWrap: z
-        .union([z.literal('always'), z.literal('never'), z.literal('preserve')])
-        .optional(),
-    htmlWhitespaceSensitivity: z
-        .union([z.literal('css'), z.literal('strict'), z.literal('ignore')])
-        .optional(),
-    vueIndentScriptAndStyle: z.boolean().optional(),
-    endOfLine: z
-        .union([
-        z.literal('auto'),
-        z.literal('lf'),
-        z.literal('crlf'),
-        z.literal('cr')
-    ])
-        .optional(),
-    embeddedLanguageFormatting: z
-        .union([z.literal('auto'), z.literal('off')])
-        .optional(),
-    singleAttributePerLine: z.boolean().optional()
-});

package/esm/typescript/EntityType.js

@@ -1,18 +0,0 @@
-import { match } from 'ts-pattern';
-export class EntityType {
-    constructor(type) {
-        Object.defineProperty(this, "type", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.type = type;
-    }
-    toString() {
-        return match(this.type)
-            .with('value', () => 'const')
-            .with('type', () => 'type')
-            .exhaustive();
-    }
-}