@skmtc/core 0.0.29 → 0.0.218

package/esm/parse/parse.js

@@ -1,69 +1,16 @@
-import { SpecVersion, createConfig, BaseResolver, makeDocumentFromString, lintDocument, detectSpec } from '@redocly/openapi-core';
-import { match } from 'ts-pattern';
 import { toDocumentV3 } from '../oas/document/toDocumentV3.js';
 import { Trail } from '../context/Trail.js';
-export const parse = (context) => {
-    const { parsedDocument, specVersion } = context;
-    const trail = Trail.create({
+export const oasToSkmtc = (context) => {
+    const { parsedDocument } = context;
+    const trail = new Trail({
         document: parsedDocument
     });
-    return match(specVersion)
-        .with(SpecVersion.OAS2, () => {
-        context.error({
-            trail,
-            message: 'OpenAPI v2 is not supported yet'
-        });
-    })
-        .with(SpecVersion.OAS3_0, () => {
-        return toDocumentV3({
-            document: parsedDocument,
-            trail,
-            context
-        });
-    })
-        .with(SpecVersion.OAS3_1, () => {
-        context.error({
-            trail,
-            message: 'OpenAPI v3.1 is not supported yet'
-        });
-    })
-        .otherwise(() => {
-        context.error({
-            trail,
-            message: `Unsupported spec version: ${specVersion}`
-        });
+    if (!parsedDocument.openapi.startsWith('3.0.')) {
+        throw new Error('Only OpenAPI v3 is supported');
+    }
+    return toDocumentV3({
+        document: parsedDocument,
+        trail,
+        context
     });
 };
-export const parseSchema = async (schemaDocument) => {
-    const config = await createConfig({
-        extends: ['recommended']
-    });
-    // const source = stringifyYaml(schemaDocument)
-    // you can also use JSON.stringify
-    const { document, issues } = await lintFromString({
-        source: schemaDocument,
-        // optionally pass path to the file for resolving $refs and proper error locations
-        // absoluteRef: 'optional/path/to/openapi.yaml',
-        config
-    });
-    const specVersion = detectSpec(document.parsed);
-    const summary = issues.reduce((acc, item) => {
-        const thing = acc[item.severity];
-        return {
-            ...acc,
-            [item.severity]: thing ? thing + 1 : 1
-        };
-    }, {});
-    return { document, issues, specVersion, summary };
-};
-const lintFromString = async (opts) => {
-    const { source, absoluteRef, externalRefResolver = new BaseResolver(opts.config.resolve) } = opts;
-    const document = makeDocumentFromString(source, absoluteRef || '/');
-    const issues = await lintDocument({
-        document,
-        ...opts,
-        externalRefResolver,
-        config: opts.config.styleguide
-    });
-    return { document, issues };
-};

package/esm/schemas/client.d.ts

@@ -0,0 +1,214 @@
+declare namespace _default {
+    let $schema: string;
+    let $id: string;
+    let title: string;
+    let description: string;
+    let type: string;
+    namespace properties {
+        namespace alias {
+            let type_1: string;
+            export { type_1 as type };
+            export namespace additionalProperties {
+                let type_2: string;
+                export { type_2 as type };
+            }
+        }
+        namespace basePath {
+            let type_3: string;
+            export { type_3 as type };
+        }
+        namespace operationPlugins {
+            let $ref: string;
+        }
+        namespace modelPlugins {
+            let $ref_1: string;
+            export { $ref_1 as $ref };
+        }
+    }
+    namespace definitions {
+        namespace Schemas {
+            let type_4: string;
+            export { type_4 as type };
+            export namespace properties_1 {
+                namespace root {
+                    let $ref_2: string;
+                    export { $ref_2 as $ref };
+                }
+                namespace schemas {
+                    let type_5: string;
+                    export { type_5 as type };
+                    export namespace additionalProperties_1 {
+                        let $ref_3: string;
+                        export { $ref_3 as $ref };
+                    }
+                    export { additionalProperties_1 as additionalProperties };
+                }
+            }
+            export { properties_1 as properties };
+        }
+        namespace Root {
+            let type_6: string;
+            export { type_6 as type };
+            export let required: string[];
+            export namespace properties_2 {
+                namespace defaultSelected {
+                    let type_7: string;
+                    export { type_7 as type };
+                }
+                namespace creatorSource {
+                    let type_8: string;
+                    export { type_8 as type };
+                }
+            }
+            export { properties_2 as properties };
+            export namespace additionalProperties_2 {
+                let type_9: string;
+                export { type_9 as type };
+            }
+            export { additionalProperties_2 as additionalProperties };
+        }
+        namespace Transformers {
+            let type_10: string;
+            export { type_10 as type };
+            export namespace additionalProperties_3 {
+                let type_11: string;
+                export { type_11 as type };
+                export namespace properties_3 {
+                    export namespace root_1 {
+                        let $ref_4: string;
+                        export { $ref_4 as $ref };
+                    }
+                    export { root_1 as root };
+                    export namespace operations {
+                        let $ref_5: string;
+                        export { $ref_5 as $ref };
+                    }
+                }
+                export { properties_3 as properties };
+            }
+            export { additionalProperties_3 as additionalProperties };
+        }
+        namespace Models {
+            let type_12: string;
+            export { type_12 as type };
+            export namespace additionalProperties_4 {
+                let type_13: string;
+                export { type_13 as type };
+                export namespace properties_4 {
+                    export namespace root_2 {
+                        let $ref_6: string;
+                        export { $ref_6 as $ref };
+                    }
+                    export { root_2 as root };
+                    export namespace models {
+                        let $ref_7: string;
+                        export { $ref_7 as $ref };
+                    }
+                }
+                export { properties_4 as properties };
+            }
+            export { additionalProperties_4 as additionalProperties };
+        }
+        namespace Operation {
+            let type_14: string;
+            export { type_14 as type };
+            let required_1: string[];
+            export { required_1 as required };
+            export namespace properties_5 {
+                namespace selected {
+                    let type_15: string;
+                    export { type_15 as type };
+                }
+                namespace name {
+                    let type_16: string;
+                    export { type_16 as type };
+                }
+                namespace importFrom {
+                    let type_17: string;
+                    export { type_17 as type };
+                }
+                namespace exportPath {
+                    let type_18: string;
+                    export { type_18 as type };
+                }
+            }
+            export { properties_5 as properties };
+        }
+        namespace Model {
+            let type_19: string;
+            export { type_19 as type };
+            let required_2: string[];
+            export { required_2 as required };
+            export namespace properties_6 {
+                export namespace selected_1 {
+                    let type_20: string;
+                    export { type_20 as type };
+                }
+                export { selected_1 as selected };
+                export namespace name_1 {
+                    let type_21: string;
+                    export { type_21 as type };
+                }
+                export { name_1 as name };
+                export namespace importFrom_1 {
+                    let type_22: string;
+                    export { type_22 as type };
+                }
+                export { importFrom_1 as importFrom };
+                export namespace exportPath_1 {
+                    let type_23: string;
+                    export { type_23 as type };
+                }
+                export { exportPath_1 as exportPath };
+            }
+            export { properties_6 as properties };
+        }
+        namespace Operations {
+            let type_24: string;
+            export { type_24 as type };
+            export namespace additionalProperties_5 {
+                let type_25: string;
+                export { type_25 as type };
+                export namespace properties_7 {
+                    export namespace get {
+                        let $ref_8: string;
+                        export { $ref_8 as $ref };
+                    }
+                    export namespace post {
+                        let $ref_9: string;
+                        export { $ref_9 as $ref };
+                    }
+                    export namespace put {
+                        let $ref_10: string;
+                        export { $ref_10 as $ref };
+                    }
+                    export namespace _delete {
+                        let $ref_11: string;
+                        export { $ref_11 as $ref };
+                    }
+                    export { _delete as delete };
+                    export namespace patch {
+                        let $ref_12: string;
+                        export { $ref_12 as $ref };
+                    }
+                    export namespace options {
+                        let $ref_13: string;
+                        export { $ref_13 as $ref };
+                    }
+                    export namespace head {
+                        let $ref_14: string;
+                        export { $ref_14 as $ref };
+                    }
+                    export namespace trace {
+                        let $ref_15: string;
+                        export { $ref_15 as $ref };
+                    }
+                }
+                export { properties_7 as properties };
+            }
+            export { additionalProperties_5 as additionalProperties };
+        }
+    }
+}
+export default _default;
+//# sourceMappingURL=client.d.ts.map

package/esm/schemas/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/schemas/client.js"],"names":[],"mappings":""}

package/esm/schemas/client.js

@@ -0,0 +1,152 @@
+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": {
+        "alias": {
+            "type": "object",
+            "additionalProperties": {
+                "type": "string"
+            }
+        },
+        "basePath": {
+            "type": "string"
+        },
+        "operationPlugins": {
+            "$ref": "#/definitions/Transformers"
+        },
+        "modelPlugins": {
+            "$ref": "#/definitions/Models"
+        }
+    },
+    "definitions": {
+        "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.d.ts

@@ -0,0 +1,5 @@
+import { Hono } from 'hono';
+import type { OperationGenerator } from '../dsl/OperationCreator.js';
+import type { ModelGenerator } from '../dsl/ModelCreator.js';
+export declare const createServer: (generators: (OperationGenerator | ModelGenerator)[]) => Hono;
+//# sourceMappingURL=createServer.d.ts.map

package/esm/server/createServer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createServer.d.ts","sourceRoot":"","sources":["../../src/server/createServer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAA;AAK3B,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAA;AACpE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAmB5D,eAAO,MAAM,YAAY,eACX,CAAC,kBAAkB,GAAG,cAAc,CAAC,EAAE,KAClD,IA2FF,CAAA"}

package/esm/server/createServer.js

@@ -0,0 +1,107 @@
+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.d.ts

@@ -0,0 +1,6 @@
+declare const brand: unique symbol;
+export type Brand<T, TBrand> = T & {
+    [brand]: TBrand;
+};
+export {};
+//# sourceMappingURL=Brand.d.ts.map

package/esm/types/Brand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Brand.d.ts","sourceRoot":"","sources":["../../src/types/Brand.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,EAAE,OAAO,MAAM,CAAA;AAElC,MAAM,MAAM,KAAK,CAAC,CAAC,EAAE,MAAM,IAAI,CAAC,GAAG;IAAE,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA"}

package/esm/types/CustomValue.d.ts

@@ -1,10 +1,18 @@
+import type { CoreContext } from '../context/CoreContext.js';
+import { ValueBase } from '../dsl/ValueBase.js';
 import type { Stringable } from '../dsl/Stringable.js';
-export declare class CustomValue {
-    type: 'custom';
+import type { GeneratorKey } from './GeneratorKeys.js';
+type CreateArgs = {
+    context: CoreContext;
     value: Stringable;
-    private constructor();
-    static create(value: Stringable): CustomValue;
+    generatorKey: GeneratorKey;
+};
+export declare class CustomValue extends ValueBase {
+    type: "custom";
+    value: Stringable;
+    constructor({ context, value, generatorKey }: CreateArgs);
     toString(): string;
 }
 export declare const isCustomValue: (value: unknown) => value is CustomValue;
+export {};
 //# sourceMappingURL=CustomValue.d.ts.map

package/esm/types/CustomValue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CustomValue.d.ts","sourceRoot":"","sources":["../../src/types/CustomValue.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AAEtD,qBAAa,WAAW;IACtB,IAAI,EAAE,QAAQ,CAAW;IACzB,KAAK,EAAE,UAAU,CAAA;IAEjB,OAAO;IAIP,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW;IAI7C,QAAQ,IAAI,MAAM;CAGnB;AAED,eAAO,MAAM,aAAa,UAAW,OAAO,yBAO3C,CAAA"}
+{"version":3,"file":"CustomValue.d.ts","sourceRoot":"","sources":["../../src/types/CustomValue.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AAC5D,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAC/C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAEtD,KAAK,UAAU,GAAG;IAChB,OAAO,EAAE,WAAW,CAAA;IACpB,KAAK,EAAE,UAAU,CAAA;IACjB,YAAY,EAAE,YAAY,CAAA;CAC3B,CAAA;AAED,qBAAa,WAAY,SAAQ,SAAS;IACxC,IAAI,WAAoB;IACxB,KAAK,EAAE,UAAU,CAAA;gBAEL,EAAE,OAAO,EAAE,KAAK,EAAE,YAAY,EAAE,EAAE,UAAU;IAMxD,QAAQ,IAAI,MAAM;CAGnB;AAED,eAAO,MAAM,aAAa,UAAW,OAAO,KAAG,KAAK,IAAI,WAOvD,CAAA"}

package/esm/types/CustomValue.js

@@ -1,5 +1,7 @@
-export class CustomValue {
-    constructor(value) {
+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,
@@ -14,9 +16,6 @@ export class CustomValue {
         });
         this.value = value;
     }
-    static create(value) {
-        return new CustomValue(value);
-    }
     toString() {
         return `${this.value}`;
     }

package/esm/types/GeneratedValue.d.ts

@@ -0,0 +1,6 @@
+import type { Stringable } from '../dsl/Stringable.js';
+import type { GeneratorKey } from './GeneratorKeys.js';
+export type GeneratedValue = Stringable & {
+    generatorKey: GeneratorKey;
+};
+//# sourceMappingURL=GeneratedValue.d.ts.map

package/esm/types/GeneratedValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GeneratedValue.d.ts","sourceRoot":"","sources":["../../src/types/GeneratedValue.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAEtD,MAAM,MAAM,cAAc,GAAG,UAAU,GAAG;IACxC,YAAY,EAAE,YAAY,CAAA;CAC3B,CAAA"}

package/esm/types/GeneratedValue.js

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

package/esm/types/GenerationType.d.ts

@@ -0,0 +1,16 @@
+/**
+ * '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 type GenerationType = 'force' | 'regular' | 'lazy';
+//# sourceMappingURL=GenerationType.d.ts.map

package/esm/types/GenerationType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GenerationType.d.ts","sourceRoot":"","sources":["../../src/types/GenerationType.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,CAAA"}